sys-utils/zramctl.c

   1 /*
   2  * zramctl - control compressed block devices in RAM
   3  *
   4  * Copyright (c) 2014 Timofey Titovets <Nefelim4ag@gmail.com>
   5  * Copyright (C) 2014 Karel Zak <kzak@redhat.com>
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License as
   9  * published by the Free Software Foundation.
  10  *
  11  * This program is distributed in the hope that it would be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along
  17  * with this program; if not, write to the Free Software Foundation, Inc.,
  18  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19  */
  20
  21 #include <getopt.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <stdarg.h>
  25 #include <assert.h>
  26 #include <sys/types.h>
  27 #include <dirent.h>
  28
  29 #include <libsmartcols.h>
  30
  31 #include "c.h"
  32 #include "nls.h"
  33 #include "closestream.h"
  34 #include "strutils.h"
  35 #include "xalloc.h"
  36 #include "sysfs.h"
  37 #include "optutils.h"
  38 #include "ismounted.h"
  39 #include "strv.h"
  40 #include "path.h"
  41 #include "pathnames.h"
  42
  43 /*#define CONFIG_ZRAM_DEBUG*/
  44
  45 #ifdef CONFIG_ZRAM_DEBUG
  46 # define DBG(x)  do { fputs("zram: ", stderr); x; fputc('\n', stderr); } while(0)
  47 #else
  48 # define DBG(x)
  49 #endif
  50
  51 /* status output columns */
  52 struct colinfo {
  53         const char *name;
  54         double whint;
  55         int flags;
  56         const char *help;
  57 };
  58
  59 enum {
  60         COL_NAME = 0,
  61         COL_DISKSIZE,
  62         COL_ORIG_SIZE,
  63         COL_COMP_SIZE,
  64         COL_ALGORITHM,
  65         COL_STREAMS,
  66         COL_ZEROPAGES,
  67         COL_MEMTOTAL,
  68         COL_MEMLIMIT,
  69         COL_MEMUSED,
  70         COL_MIGRATED,
  71         COL_MOUNTPOINT
  72 };
  73
  74 static const struct colinfo infos[] = {
  75         [COL_NAME]      = { "NAME",      0.25, 0, N_("zram device name") },
  76         [COL_DISKSIZE]  = { "DISKSIZE",     5, SCOLS_FL_RIGHT, N_("limit on the uncompressed amount of data") },
  77         [COL_ORIG_SIZE] = { "DATA",         5, SCOLS_FL_RIGHT, N_("uncompressed size of stored data") },
  78         [COL_COMP_SIZE] = { "COMPR",        5, SCOLS_FL_RIGHT, N_("compressed size of stored data") },
  79         [COL_ALGORITHM] = { "ALGORITHM",    3, 0, N_("the selected compression algorithm") },
  80         [COL_STREAMS]   = { "STREAMS",      3, SCOLS_FL_RIGHT, N_("number of concurrent compress operations") },
  81         [COL_ZEROPAGES] = { "ZERO-PAGES",   3, SCOLS_FL_RIGHT, N_("empty pages with no allocated memory") },
  82         [COL_MEMTOTAL]  = { "TOTAL",        5, SCOLS_FL_RIGHT, N_("all memory including allocator fragmentation and metadata overhead") },
  83         [COL_MEMLIMIT]  = { "MEM-LIMIT",    5, SCOLS_FL_RIGHT, N_("memory limit used to store compressed data") },
  84         [COL_MEMUSED]   = { "MEM-USED",     5, SCOLS_FL_RIGHT, N_("memory zram have been consumed to store compressed data") },
  85         [COL_MIGRATED]  = { "MIGRATED",     5, SCOLS_FL_RIGHT, N_("number of objects migrated by compaction") },
  86         [COL_MOUNTPOINT]= { "MOUNTPOINT",0.10, SCOLS_FL_TRUNC, N_("where the device is mounted") },
  87 };
  88
  89 static int columns[ARRAY_SIZE(infos) * 2] = {-1};
  90 static int ncolumns;
  91
  92 enum {
  93         MM_ORIG_DATA_SIZE = 0,
  94         MM_COMPR_DATA_SIZE,
  95         MM_MEM_USED_TOTAL,
  96         MM_MEM_LIMIT,
  97         MM_MEM_USED_MAX,
  98         MM_ZERO_PAGES,
  99         MM_NUM_MIGRATED
 100 };
 101
 102 static const char *mm_stat_names[] = {
 103         [MM_ORIG_DATA_SIZE]  = "orig_data_size",
 104         [MM_COMPR_DATA_SIZE] = "compr_data_size",
 105         [MM_MEM_USED_TOTAL]  = "mem_used_total",
 106         [MM_MEM_LIMIT]       = "mem_limit",
 107         [MM_MEM_USED_MAX]    = "mem_used_max",
 108         [MM_ZERO_PAGES]      = "zero_pages",
 109         [MM_NUM_MIGRATED]    = "num_migrated"
 110 };
 111
 112 struct zram {
 113         char    devname[32];
 114         struct  path_cxt *sysfs;        /* device specific sysfs directory */
 115         char    **mm_stat;
 116
 117         unsigned int mm_stat_probed : 1,
 118                      control_probed : 1,
 119                      has_control : 1;   /* has /sys/class/zram-control/ */
 120 };
 121
 122 static unsigned int raw, no_headings, inbytes;
 123 static struct path_cxt *__control;
 124
 125 static int get_column_id(int num)
 126 {
 127         assert(num < ncolumns);
 128         assert(columns[num] < (int) ARRAY_SIZE(infos));
 129         return columns[num];
 130 }
 131
 132 static const struct colinfo *get_column_info(int num)
 133 {
 134         return &infos[ get_column_id(num) ];
 135 }
 136
 137 static int column_name_to_id(const char *name, size_t namesz)
 138 {
 139         size_t i;
 140
 141         for (i = 0; i < ARRAY_SIZE(infos); i++) {
 142                 const char *cn = infos[i].name;
 143
 144                 if (!strncasecmp(name, cn, namesz) && !*(cn + namesz))
 145                         return i;
 146         }
 147         warnx(_("unknown column: %s"), name);
 148         return -1;
 149 }
 150
 151 static void zram_reset_stat(struct zram *z)
 152 {
 153         if (z) {
 154                 strv_free(z->mm_stat);
 155                 z->mm_stat = NULL;
 156                 z->mm_stat_probed = 0;
 157         }
 158 }
 159
 160 static void zram_set_devname(struct zram *z, const char *devname, size_t n)
 161 {
 162         assert(z);
 163
 164         if (!devname)
 165                 snprintf(z->devname, sizeof(z->devname), "/dev/zram%zu", n);
 166         else
 167                 xstrncpy(z->devname, devname, sizeof(z->devname));
 168
 169         DBG(fprintf(stderr, "set devname: %s", z->devname));
 170         ul_unref_path(z->sysfs);
 171         z->sysfs = NULL;
 172         zram_reset_stat(z);
 173 }
 174
 175 static int zram_get_devnum(struct zram *z)
 176 {
 177         int n;
 178
 179         assert(z);
 180
 181         if (sscanf(z->devname, "/dev/zram%d", &n) == 1)
 182                 return n;
 183         return -EINVAL;
 184 }
 185
 186 static struct zram *new_zram(const char *devname)
 187 {
 188         struct zram *z = xcalloc(1, sizeof(struct zram));
 189
 190         DBG(fprintf(stderr, "new: %p", z));
 191         if (devname)
 192                 zram_set_devname(z, devname, 0);
 193         return z;
 194 }
 195
 196 static void free_zram(struct zram *z)
 197 {
 198         if (!z)
 199                 return;
 200         DBG(fprintf(stderr, "free: %p", z));
 201         ul_unref_path(z->sysfs);
 202         zram_reset_stat(z);
 203         free(z);
 204 }
 205
 206 static struct path_cxt *zram_get_sysfs(struct zram *z)
 207 {
 208         assert(z);
 209
 210         if (!z->sysfs) {
 211                 dev_t devno = sysfs_devname_to_devno(z->devname);
 212                 if (!devno)
 213                         return NULL;
 214                 z->sysfs = ul_new_sysfs_path(devno, NULL, NULL);
 215                 if (!z->sysfs)
 216                         return NULL;
 217                 if (*z->devname != '/')
 218                         /* canonicalize the device name according to /sys */
 219                         sysfs_blkdev_get_path(z->sysfs, z->devname, sizeof(z->devname));
 220         }
 221
 222         return z->sysfs;
 223 }
 224
 225 static inline int zram_exist(struct zram *z)
 226 {
 227         assert(z);
 228
 229         errno = 0;
 230         if (zram_get_sysfs(z) == NULL) {
 231                 errno = ENODEV;
 232                 return 0;
 233         }
 234
 235         DBG(fprintf(stderr, "%s exists", z->devname));
 236         return 1;
 237 }
 238
 239 static int zram_set_u64parm(struct zram *z, const char *attr, uint64_t num)
 240 {
 241         struct path_cxt *sysfs = zram_get_sysfs(z);
 242         if (!sysfs)
 243                 return -EINVAL;
 244         DBG(fprintf(stderr, "%s writing %ju to %s", z->devname, num, attr));
 245         return ul_path_write_u64(sysfs, num, attr);
 246 }
 247
 248 static int zram_set_strparm(struct zram *z, const char *attr, const char *str)
 249 {
 250         struct path_cxt *sysfs = zram_get_sysfs(z);
 251         if (!sysfs)
 252                 return -EINVAL;
 253         DBG(fprintf(stderr, "%s writing %s to %s", z->devname, str, attr));
 254         return ul_path_write_string(sysfs, str, attr);
 255 }
 256
 257
 258 static int zram_used(struct zram *z)
 259 {
 260         uint64_t size;
 261         struct path_cxt *sysfs = zram_get_sysfs(z);
 262
 263         if (sysfs &&
 264             ul_path_read_u64(sysfs, &size, "disksize") == 0 &&
 265             size > 0) {
 266
 267                 DBG(fprintf(stderr, "%s used", z->devname));
 268                 return 1;
 269         }
 270         DBG(fprintf(stderr, "%s unused", z->devname));
 271         return 0;
 272 }
 273
 274 static int zram_has_control(struct zram *z)
 275 {
 276         if (!z->control_probed) {
 277                 z->has_control = access(_PATH_SYS_CLASS "/zram-control/", F_OK) == 0 ? 1 : 0;
 278                 z->control_probed = 1;
 279                 DBG(fprintf(stderr, "zram-control: %s", z->has_control ? "yes" : "no"));
 280         }
 281
 282         return z->has_control;
 283 }
 284
 285 static struct path_cxt *zram_get_control(void)
 286 {
 287         if (!__control)
 288                 __control = ul_new_path(_PATH_SYS_CLASS "/zram-control");
 289         return __control;
 290 }
 291
 292 static int zram_control_add(struct zram *z)
 293 {
 294         int n;
 295         struct path_cxt *ctl;
 296
 297         if (!zram_has_control(z) || !(ctl = zram_get_control()))
 298                 return -ENOSYS;
 299
 300         if (ul_path_read_s32(ctl, &n, "hot_add") != 0 || n < 0)
 301                 return n;
 302
 303         DBG(fprintf(stderr, "hot-add: %d", n));
 304         zram_set_devname(z, NULL, n);
 305         return 0;
 306 }
 307
 308 static int zram_control_remove(struct zram *z)
 309 {
 310         struct path_cxt *ctl;
 311         int n;
 312
 313         if (!zram_has_control(z) || !(ctl = zram_get_control()))
 314                 return -ENOSYS;
 315
 316         n = zram_get_devnum(z);
 317         if (n < 0)
 318                 return n;
 319
 320         DBG(fprintf(stderr, "hot-remove: %d", n));
 321         return ul_path_write_u64(ctl, n, "hot_remove");
 322 }
 323
 324 static struct zram *find_free_zram(void)
 325 {
 326         struct zram *z = new_zram(NULL);
 327         size_t i;
 328         int isfree = 0;
 329
 330         for (i = 0; isfree == 0; i++) {
 331                 DBG(fprintf(stderr, "find free: checking zram%zu", i));
 332                 zram_set_devname(z, NULL, i);
 333                 if (!zram_exist(z) && zram_control_add(z) != 0)
 334                         break;
 335                 isfree = !zram_used(z);
 336         }
 337         if (!isfree) {
 338                 free_zram(z);
 339                 z = NULL;
 340         }
 341         return z;
 342 }
 343
 344 static char *get_mm_stat(struct zram *z, size_t idx, int bytes)
 345 {
 346         struct path_cxt *sysfs;
 347         const char *name;
 348         char *str = NULL;
 349         uint64_t num;
 350
 351         assert(idx < ARRAY_SIZE(mm_stat_names));
 352         assert(z);
 353
 354         sysfs = zram_get_sysfs(z);
 355         if (!sysfs)
 356                 return NULL;
 357
 358         /* Linux >= 4.1 uses /sys/block/zram<id>/mm_stat */
 359         if (!z->mm_stat && !z->mm_stat_probed) {
 360                 if (ul_path_read_string(sysfs, &str, "mm_stat") > 0 && str) {
 361                         z->mm_stat = strv_split(str, " ");
 362
 363                         /* make sure kernel provides mm_stat as expected */
 364                         if (strv_length(z->mm_stat) < ARRAY_SIZE(mm_stat_names)) {
 365                                 strv_free(z->mm_stat);
 366                                 z->mm_stat = NULL;
 367                         }
 368                 }
 369                 z->mm_stat_probed = 1;
 370                 free(str);
 371                 str = NULL;
 372         }
 373
 374         if (z->mm_stat) {
 375                 if (bytes)
 376                         return xstrdup(z->mm_stat[idx]);
 377
 378                 num = strtou64_or_err(z->mm_stat[idx], _("Failed to parse mm_stat"));
 379                 return size_to_human_string(SIZE_SUFFIX_1LETTER, num);
 380         }
 381
 382         /* Linux < 4.1 uses /sys/block/zram<id>/<attrname> */
 383         name = mm_stat_names[idx];
 384         if (bytes) {
 385                 ul_path_read_string(sysfs, &str, name);
 386                 return str;
 387
 388         }
 389
 390         if (ul_path_read_u64(sysfs, &num, name) == 0)
 391                 return size_to_human_string(SIZE_SUFFIX_1LETTER, num);
 392
 393         return NULL;
 394 }
 395
 396 static void fill_table_row(struct libscols_table *tb, struct zram *z)
 397 {
 398         static struct libscols_line *ln;
 399         struct path_cxt *sysfs;
 400         size_t i;
 401         uint64_t num;
 402
 403         assert(tb);
 404         assert(z);
 405
 406         DBG(fprintf(stderr, "%s: filling status table", z->devname));
 407
 408         sysfs = zram_get_sysfs(z);
 409         if (!sysfs)
 410                 return;
 411
 412         ln = scols_table_new_line(tb, NULL);
 413         if (!ln)
 414                 err(EXIT_FAILURE, _("failed to allocate output line"));
 415
 416         for (i = 0; i < (size_t) ncolumns; i++) {
 417                 char *str = NULL;
 418
 419                 switch (get_column_id(i)) {
 420                 case COL_NAME:
 421                         str = xstrdup(z->devname);
 422                         break;
 423                 case COL_DISKSIZE:
 424                         if (inbytes)
 425                                 ul_path_read_string(sysfs, &str, "disksize");
 426
 427                         else if (ul_path_read_u64(sysfs, &num, "disksize") == 0)
 428                                 str = size_to_human_string(SIZE_SUFFIX_1LETTER, num);
 429                         break;
 430                 case COL_ALGORITHM:
 431                 {
 432                         char *alg = NULL;
 433
 434                         ul_path_read_string(sysfs, &alg, "comp_algorithm");
 435                         if (alg) {
 436                                 char* lbr = strrchr(alg, '[');
 437                                 char* rbr = strrchr(alg, ']');
 438
 439                                 if (lbr != NULL && rbr != NULL && rbr - lbr > 1)
 440                                         str = xstrndup(lbr + 1, rbr - lbr - 1);
 441                                 free(alg);
 442                         }
 443                         break;
 444                 }
 445                 case COL_MOUNTPOINT:
 446                 {
 447                         char path[PATH_MAX] = { '\0' };
 448                         int fl;
 449
 450                         check_mount_point(z->devname, &fl, path, sizeof(path));
 451                         if (*path)
 452                                 str = xstrdup(path);
 453                         break;
 454                 }
 455                 case COL_STREAMS:
 456                         ul_path_read_string(sysfs, &str, "max_comp_streams");
 457                         break;
 458                 case COL_ZEROPAGES:
 459                         str = get_mm_stat(z, MM_ZERO_PAGES, 1);
 460                         break;
 461                 case COL_ORIG_SIZE:
 462                         str = get_mm_stat(z, MM_ORIG_DATA_SIZE, inbytes);
 463                         break;
 464                 case COL_COMP_SIZE:
 465                         str = get_mm_stat(z, MM_COMPR_DATA_SIZE, inbytes);
 466                         break;
 467                 case COL_MEMTOTAL:
 468                         str = get_mm_stat(z, MM_MEM_USED_TOTAL, inbytes);
 469                         break;
 470                 case COL_MEMLIMIT:
 471                         str = get_mm_stat(z, MM_MEM_LIMIT, inbytes);
 472                         break;
 473                 case COL_MEMUSED:
 474                         str = get_mm_stat(z, MM_MEM_USED_MAX, inbytes);
 475                         break;
 476                 case COL_MIGRATED:
 477                         str = get_mm_stat(z, MM_NUM_MIGRATED, inbytes);
 478                         break;
 479                 }
 480                 if (str && scols_line_refer_data(ln, i, str))
 481                         err(EXIT_FAILURE, _("failed to add output data"));
 482         }
 483 }
 484
 485 static void status(struct zram *z)
 486 {
 487         struct libscols_table *tb;
 488         size_t i;
 489         DIR *dir;
 490         struct dirent *d;
 491
 492         scols_init_debug(0);
 493
 494         tb = scols_new_table();
 495         if (!tb)
 496                 err(EXIT_FAILURE, _("failed to allocate output table"));
 497
 498         scols_table_enable_raw(tb, raw);
 499         scols_table_enable_noheadings(tb, no_headings);
 500
 501         for (i = 0; i < (size_t) ncolumns; i++) {
 502                 const struct colinfo *col = get_column_info(i);
 503
 504                 if (!scols_table_new_column(tb, col->name, col->whint, col->flags))
 505                         err(EXIT_FAILURE, _("failed to initialize output column"));
 506         }
 507
 508         if (z) {
 509                 /* just one device specified */
 510                 fill_table_row(tb, z);
 511                 goto print_table;
 512         }
 513
 514         /* list all used devices */
 515         z = new_zram(NULL);
 516         if (!(dir = opendir(_PATH_DEV)))
 517                 err(EXIT_FAILURE, _("cannot open %s"), _PATH_DEV);
 518
 519         while ((d = readdir(dir))) {
 520                 int n;
 521                 if (sscanf(d->d_name, "zram%d", &n) != 1)
 522                         continue;
 523                 zram_set_devname(z, NULL, n);
 524                 if (zram_exist(z) && zram_used(z))
 525                         fill_table_row(tb, z);
 526         }
 527         closedir(dir);
 528         free_zram(z);
 529
 530 print_table:
 531         scols_print_table(tb);
 532         scols_unref_table(tb);
 533 }
 534
 535 static void __attribute__((__noreturn__)) usage(void)
 536 {
 537         FILE *out = stdout;
 538         size_t i;
 539
 540         fputs(USAGE_HEADER, out);
 541         fprintf(out, _( " %1$s [options] <device>\n"
 542                         " %1$s -r <device> [...]\n"
 543                         " %1$s [options] -f | <device> -s <size>\n"),
 544                         program_invocation_short_name);
 545
 546         fputs(USAGE_SEPARATOR, out);
 547         fputs(_("Set up and control zram devices.\n"), out);
 548
 549         fputs(USAGE_OPTIONS, out);
 550         fputs(_(" -a, --algorithm lzo|lz4|lz4hc|deflate|842   compression algorithm to use\n"), out);
 551         fputs(_(" -b, --bytes               print sizes in bytes rather than in human readable format\n"), out);
 552         fputs(_(" -f, --find                find a free device\n"), out);
 553         fputs(_(" -n, --noheadings          don't print headings\n"), out);
 554         fputs(_(" -o, --output <list>       columns to use for status output\n"), out);
 555         fputs(_("     --output-all          output all columns\n"), out);
 556         fputs(_("     --raw                 use raw status output format\n"), out);
 557         fputs(_(" -r, --reset               reset all specified devices\n"), out);
 558         fputs(_(" -s, --size <size>         device size\n"), out);
 559         fputs(_(" -t, --streams <number>    number of compression streams\n"), out);
 560
 561         fputs(USAGE_SEPARATOR, out);
 562         printf(USAGE_HELP_OPTIONS(27));
 563
 564         fputs(USAGE_ARGUMENTS, out);
 565         printf(USAGE_ARG_SIZE(_("<size>")));
 566
 567         fputs(USAGE_COLUMNS, out);
 568         for (i = 0; i < ARRAY_SIZE(infos); i++)
 569                 fprintf(out, " %11s  %s\n", infos[i].name, _(infos[i].help));
 570
 571         printf(USAGE_MAN_TAIL("zramctl(8)"));
 572         exit(EXIT_SUCCESS);
 573 }
 574
 575 /* actions */
 576 enum {
 577         A_NONE = 0,
 578         A_STATUS,
 579         A_CREATE,
 580         A_FINDONLY,
 581         A_RESET
 582 };
 583
 584 int main(int argc, char **argv)
 585 {
 586         uintmax_t size = 0, nstreams = 0;
 587         char *algorithm = NULL;
 588         int rc = 0, c, find = 0, act = A_NONE;
 589         struct zram *zram = NULL;
 590
 591         enum {
 592                 OPT_RAW = CHAR_MAX + 1,
 593                 OPT_LIST_TYPES
 594         };
 595
 596         static const struct option longopts[] = {
 597                 { "algorithm", required_argument, NULL, 'a' },
 598                 { "bytes",     no_argument, NULL, 'b' },
 599                 { "find",      no_argument, NULL, 'f' },
 600                 { "help",      no_argument, NULL, 'h' },
 601                 { "output",    required_argument, NULL, 'o' },
 602                 { "output-all",no_argument, NULL, OPT_LIST_TYPES },
 603                 { "noheadings",no_argument, NULL, 'n' },
 604                 { "reset",     no_argument, NULL, 'r' },
 605                 { "raw",       no_argument, NULL, OPT_RAW },
 606                 { "size",      required_argument, NULL, 's' },
 607                 { "streams",   required_argument, NULL, 't' },
 608                 { "version",   no_argument, NULL, 'V' },
 609                 { NULL, 0, NULL, 0 }
 610         };
 611
 612         static const ul_excl_t excl[] = {
 613                 { 'f', 'o', 'r' },
 614                 { 'o', 'r', 's' },
 615                 { 0 }
 616         };
 617         int excl_st[ARRAY_SIZE(excl)] = UL_EXCL_STATUS_INIT;
 618
 619         setlocale(LC_ALL, "");
 620         bindtextdomain(PACKAGE, LOCALEDIR);
 621         textdomain(PACKAGE);
 622         close_stdout_atexit();
 623
 624         while ((c = getopt_long(argc, argv, "a:bfho:nrs:t:V", longopts, NULL)) != -1) {
 625
 626                 err_exclusive_options(c, longopts, excl, excl_st);
 627
 628                 switch (c) {
 629                 case 'a':
 630                         algorithm = optarg;
 631                         break;
 632                 case 'b':
 633                         inbytes = 1;
 634                         break;
 635                 case 'f':
 636                         find = 1;
 637                         break;
 638                 case 'o':
 639                         ncolumns = string_to_idarray(optarg,
 640                                                      columns, ARRAY_SIZE(columns),
 641                                                      column_name_to_id);
 642                         if (ncolumns < 0)
 643                                 return EXIT_FAILURE;
 644                         break;
 645                 case OPT_LIST_TYPES:
 646                         for (ncolumns = 0; (size_t)ncolumns < ARRAY_SIZE(infos); ncolumns++)
 647                                 columns[ncolumns] = ncolumns;
 648                         break;
 649                 case 's':
 650                         size = strtosize_or_err(optarg, _("failed to parse size"));
 651                         act = A_CREATE;
 652                         break;
 653                 case 't':
 654                         nstreams = strtou64_or_err(optarg, _("failed to parse streams"));
 655                         break;
 656                 case 'r':
 657                         act = A_RESET;
 658                         break;
 659                 case OPT_RAW:
 660                         raw = 1;
 661                         break;
 662                 case 'n':
 663                         no_headings = 1;
 664                         break;
 665
 666                 case 'V':
 667                         print_version(EXIT_SUCCESS);
 668                 case 'h':
 669                         usage();
 670                 default:
 671                         errtryhelp(EXIT_FAILURE);
 672                 }
 673         }
 674
 675         if (find && optind < argc)
 676                 errx(EXIT_FAILURE, _("option --find is mutually exclusive "
 677                                      "with <device>"));
 678         if (act == A_NONE)
 679                 act = find ? A_FINDONLY : A_STATUS;
 680
 681         if (act != A_RESET && optind + 1 < argc)
 682                 errx(EXIT_FAILURE, _("only one <device> at a time is allowed"));
 683
 684         if ((act == A_STATUS || act == A_FINDONLY) && (algorithm || nstreams))
 685                 errx(EXIT_FAILURE, _("options --algorithm and --streams "
 686                                      "must be combined with --size"));
 687
 688         ul_path_init_debug();
 689         ul_sysfs_init_debug();
 690
 691         switch (act) {
 692         case A_STATUS:
 693                 if (!ncolumns) {                /* default columns */
 694                         columns[ncolumns++] = COL_NAME;
 695                         columns[ncolumns++] = COL_ALGORITHM;
 696                         columns[ncolumns++] = COL_DISKSIZE;
 697                         columns[ncolumns++] = COL_ORIG_SIZE;
 698                         columns[ncolumns++] = COL_COMP_SIZE;
 699                         columns[ncolumns++] = COL_MEMTOTAL;
 700                         columns[ncolumns++] = COL_STREAMS;
 701                         columns[ncolumns++] = COL_MOUNTPOINT;
 702                 }
 703                 if (optind < argc) {
 704                         zram = new_zram(argv[optind++]);
 705                         if (!zram_exist(zram))
 706                                 err(EXIT_FAILURE, "%s", zram->devname);
 707                 }
 708                 status(zram);
 709                 free_zram(zram);
 710                 break;
 711         case A_RESET:
 712                 if (optind == argc)
 713                         errx(EXIT_FAILURE, _("no device specified"));
 714                 while (optind < argc) {
 715                         zram = new_zram(argv[optind]);
 716                         if (!zram_exist(zram)
 717                             || zram_set_u64parm(zram, "reset", 1)) {
 718                                 warn(_("%s: failed to reset"), zram->devname);
 719                                 rc = 1;
 720                         }
 721                         zram_control_remove(zram);
 722                         free_zram(zram);
 723                         optind++;
 724                 }
 725                 break;
 726         case A_FINDONLY:
 727                 zram = find_free_zram();
 728                 if (!zram)
 729                         errx(EXIT_FAILURE, _("no free zram device found"));
 730                 printf("%s\n", zram->devname);
 731                 free_zram(zram);
 732                 break;
 733         case A_CREATE:
 734                 if (find) {
 735                         zram = find_free_zram();
 736                         if (!zram)
 737                                 errx(EXIT_FAILURE, _("no free zram device found"));
 738                 } else if (optind == argc)
 739                         errx(EXIT_FAILURE, _("no device specified"));
 740                 else {
 741                         zram = new_zram(argv[optind]);
 742                         if (!zram_exist(zram))
 743                                 err(EXIT_FAILURE, "%s", zram->devname);
 744                 }
 745
 746                 if (zram_set_u64parm(zram, "reset", 1))
 747                         err(EXIT_FAILURE, _("%s: failed to reset"), zram->devname);
 748
 749                 if (nstreams &&
 750                     zram_set_u64parm(zram, "max_comp_streams", nstreams))
 751                         err(EXIT_FAILURE, _("%s: failed to set number of streams"), zram->devname);
 752
 753                 if (algorithm &&
 754                     zram_set_strparm(zram, "comp_algorithm", algorithm))
 755                         err(EXIT_FAILURE, _("%s: failed to set algorithm"), zram->devname);
 756
 757                 if (zram_set_u64parm(zram, "disksize", size))
 758                         err(EXIT_FAILURE, _("%s: failed to set disksize (%ju bytes)"),
 759                                 zram->devname, size);
 760                 if (find)
 761                         printf("%s\n", zram->devname);
 762                 free_zram(zram);
 763                 break;
 764         }
 765
 766         ul_unref_path(__control);
 767         return rc ? EXIT_FAILURE : EXIT_SUCCESS;
 768 }