lib/ext2fs/tst_bitmaps.c

   1 /*
   2  * tst_bitmaps.c
   3  *
   4  * Copyright (C) 2011 Theodore Ts'o.
   5  *
   6  * %Begin-Header%
   7  * This file may be redistributed under the terms of the GNU Library
   8  * General Public License, version 2.
   9  * %End-Header%
  10  */
  11
  12 #include "config.h"
  13 #include <unistd.h>
  14 #include <stdlib.h>
  15 #include <stdio.h>
  16 #ifdef HAVE_GETOPT_H
  17 #include <getopt.h>
  18 #endif
  19 #include <string.h>
  20 #include <fcntl.h>
  21 #include <time.h>
  22 #include <sys/stat.h>
  23 #include <sys/types.h>
  24 #include "ss/ss.h"
  25
  26 #include "ext2_fs.h"
  27 #include "ext2fs.h"
  28 #include "ext2fsP.h"
  29
  30 extern ss_request_table tst_bitmaps_cmds;
  31
  32 static char subsystem_name[] = "tst_bitmaps";
  33 static char version[] = "1.0";
  34
  35 ext2_filsys     test_fs;
  36 int             exit_status = 0;
  37
  38 static int source_file(const char *cmd_file, int sci_idx)
  39 {
  40         FILE            *f;
  41         char            buf[256];
  42         char            *cp;
  43         int             retval;
  44         int             noecho;
  45
  46         if (strcmp(cmd_file, "-") == 0)
  47                 f = stdin;
  48         else {
  49                 f = fopen(cmd_file, "r");
  50                 if (!f) {
  51                         perror(cmd_file);
  52                         exit(1);
  53                 }
  54         }
  55         fflush(stdout);
  56         fflush(stderr);
  57         setbuf(stdout, NULL);
  58         setbuf(stderr, NULL);
  59         while (!feof(f)) {
  60                 if (fgets(buf, sizeof(buf), f) == NULL)
  61                         break;
  62                 if (buf[0] == '#')
  63                         continue;
  64                 noecho = 0;
  65                 if (buf[0] == '-') {
  66                         noecho = 1;
  67                         buf[0] = ' ';
  68                 }
  69                 cp = strchr(buf, '\n');
  70                 if (cp)
  71                         *cp = 0;
  72                 cp = strchr(buf, '\r');
  73                 if (cp)
  74                         *cp = 0;
  75                 if (!noecho)
  76                         printf("%s: %s\n", subsystem_name, buf);
  77                 retval = ss_execute_line(sci_idx, buf);
  78                 if (retval) {
  79                         ss_perror(sci_idx, retval, buf);
  80                         exit_status++;
  81                 }
  82         }
  83         return exit_status;
  84 }
  85
  86
  87 /*
  88  * This function resets the libc getopt() function, which keeps
  89  * internal state.  Bad design!  Stupid libc API designers!  No
  90  * biscuit!
  91  *
  92  * BSD-derived getopt() functions require that optind be reset to 1 in
  93  * order to reset getopt() state.  This used to be generally accepted
  94  * way of resetting getopt().  However, glibc's getopt()
  95  * has additional getopt() state beyond optind, and requires that
  96  * optind be set zero to reset its state.  So the unfortunate state of
  97  * affairs is that BSD-derived versions of getopt() misbehave if
  98  * optind is set to 0 in order to reset getopt(), and glibc's getopt()
  99  * will core dump if optind is set 1 in order to reset getopt().
 100  *
 101  * More modern versions of BSD require that optreset be set to 1 in
 102  * order to reset getopt().   Sigh.  Standards, anyone?
 103  *
 104  * We hide the hair here.
 105  */
 106 void reset_getopt(void)
 107 {
 108 #if defined(__GLIBC__) || defined(__linux__)
 109         optind = 0;
 110 #else
 111         optind = 1;
 112 #endif
 113 #ifdef HAVE_OPTRESET
 114         optreset = 1;           /* Makes BSD getopt happy */
 115 #endif
 116 }
 117
 118 /*
 119  * This function will convert a string to an unsigned long, printing
 120  * an error message if it fails, and returning success or failure in err.
 121  */
 122 unsigned long parse_ulong(const char *str, const char *cmd,
 123                           const char *descr, int *err)
 124 {
 125         char            *tmp;
 126         unsigned long   ret;
 127
 128         ret = strtoul(str, &tmp, 0);
 129         if (*tmp == 0) {
 130                 if (err)
 131                         *err = 0;
 132                 return ret;
 133         }
 134         com_err(cmd, 0, "Bad %s - %s", descr, str);
 135         if (err)
 136                 *err = 1;
 137         else
 138                 exit(1);
 139         return 0;
 140 }
 141
 142
 143 int check_fs_open(const char *name)
 144 {
 145         if (!test_fs) {
 146                 com_err(name, 0, "Filesystem not open");
 147                 return 1;
 148         }
 149         return 0;
 150 }
 151
 152 static void setup_filesystem(const char *name,
 153                              unsigned int blocks, unsigned int inodes,
 154                              unsigned int type, int flags)
 155 {
 156         struct ext2_super_block param;
 157         errcode_t retval;
 158
 159         memset(&param, 0, sizeof(param));
 160         ext2fs_blocks_count_set(&param, blocks);
 161         param.s_inodes_count = inodes;
 162
 163         retval = ext2fs_initialize("test fs", flags, &param,
 164                                    test_io_manager, &test_fs);
 165
 166         if (retval) {
 167                 com_err(name, retval, "while initializing filesystem");
 168                 return;
 169         }
 170         test_fs->default_bitmap_type = type;
 171         ext2fs_free_block_bitmap(test_fs->block_map);
 172         test_fs->block_map = 0;
 173         ext2fs_free_inode_bitmap(test_fs->inode_map);
 174         test_fs->inode_map = 0;
 175         retval = ext2fs_allocate_block_bitmap(test_fs, "block bitmap",
 176                                               &test_fs->block_map);
 177         if (retval) {
 178                 com_err(name, retval, "while allocating block bitmap");
 179                 goto errout;
 180         }
 181         retval = ext2fs_allocate_inode_bitmap(test_fs, "inode bitmap",
 182                                               &test_fs->inode_map);
 183         if (retval) {
 184                 com_err(name, retval, "while allocating inode bitmap");
 185                 goto errout;
 186         }
 187         return;
 188
 189 errout:
 190         ext2fs_close_free(&test_fs);
 191 }
 192
 193 void setup_cmd(int argc, ss_argv_t argv,
 194                int sci_idx EXT2FS_ATTR((unused)),
 195                void *infop EXT2FS_ATTR((unused)))
 196 {
 197         int             c, err;
 198         unsigned int    blocks = 128;
 199         unsigned int    inodes = 0;
 200         unsigned int    type = EXT2FS_BMAP64_BITARRAY;
 201         int             flags = EXT2_FLAG_64BITS;
 202
 203         if (test_fs)
 204                 ext2fs_close_free(&test_fs);
 205
 206         reset_getopt();
 207         while ((c = getopt(argc, argv, "b:i:lt:")) != EOF) {
 208                 switch (c) {
 209                 case 'b':
 210                         blocks = parse_ulong(optarg, argv[0],
 211                                              "number of blocks", &err);
 212                         if (err)
 213                                 return;
 214                         break;
 215                 case 'i':
 216                         inodes = parse_ulong(optarg, argv[0],
 217                                              "number of blocks", &err);
 218                         if (err)
 219                                 return;
 220                         break;
 221                 case 'l':       /* Legacy bitmaps */
 222                         flags = 0;
 223                         break;
 224                 case 't':
 225                         type = parse_ulong(optarg, argv[0],
 226                                            "bitmap backend type", &err);
 227                         if (err)
 228                                 return;
 229                         break;
 230                 default:
 231                         fprintf(stderr, "%s: usage: setup [-b blocks] "
 232                                 "[-i inodes] [-t type]\n", argv[0]);
 233                         return;
 234                 }
 235         }
 236         setup_filesystem(argv[0], blocks, inodes, type, flags);
 237 }
 238
 239 void close_cmd(int argc, char **argv, int sci_idx EXT2FS_ATTR((unused)),
 240                void *infop EXT2FS_ATTR((unused)))
 241 {
 242         if (check_fs_open(argv[0]))
 243                 return;
 244
 245         ext2fs_close_free(&test_fs);
 246 }
 247
 248
 249 void dump_bitmap(ext2fs_generic_bitmap bmap, unsigned int start, unsigned num)
 250 {
 251         unsigned char   *buf;
 252         errcode_t       retval;
 253         int             i, len = (num - start + 7) / 8;
 254
 255         buf = malloc(len);
 256         if (!buf) {
 257                 com_err("dump_bitmap", 0, "couldn't allocate buffer");
 258                 return;
 259         }
 260         memset(buf, 0, len);
 261         retval = ext2fs_get_generic_bmap_range(bmap, (__u64) start, num, buf);
 262         if (retval) {
 263                 com_err("dump_bitmap", retval,
 264                         "while calling ext2fs_generic_bmap_range");
 265                 free(buf);
 266                 return;
 267         }
 268         for (i=0; i < len; i++)
 269                 printf("%02x", buf[i]);
 270         printf("\n");
 271         printf("bits set: %u\n", ext2fs_bitcount(buf, len));
 272         free(buf);
 273 }
 274
 275 void dump_inode_bitmap_cmd(int argc, ss_argv_t argv,
 276                            int sci_idx EXT2FS_ATTR((unused)),
 277                            void *infop EXT2FS_ATTR((unused)))
 278 {
 279         if (check_fs_open(argv[0]))
 280                 return;
 281
 282         printf("inode bitmap: ");
 283         dump_bitmap(test_fs->inode_map, 1, test_fs->super->s_inodes_count);
 284 }
 285
 286 void dump_block_bitmap_cmd(int argc, ss_argv_t argv,
 287                            int sci_idx EXT2FS_ATTR((unused)),
 288                            void *infop EXT2FS_ATTR((unused)))
 289 {
 290         if (check_fs_open(argv[0]))
 291                 return;
 292
 293         printf("block bitmap: ");
 294         dump_bitmap(test_fs->block_map, test_fs->super->s_first_data_block,
 295                     test_fs->super->s_blocks_count);
 296 }
 297
 298 void do_setb(int argc, ss_argv_t argv,
 299              int sci_idx EXT2FS_ATTR((unused)),
 300              void *infop EXT2FS_ATTR((unused)))
 301 {
 302         unsigned int block, num;
 303         int err;
 304         int test_result, op_result;
 305
 306         if (check_fs_open(argv[0]))
 307                 return;
 308
 309         if (argc != 2 && argc != 3) {
 310                 com_err(argv[0], 0, "Usage: setb <block> [num]");
 311                 return;
 312         }
 313
 314         block = parse_ulong(argv[1], argv[0], "block", &err);
 315         if (err)
 316                 return;
 317
 318         if (argc == 3) {
 319                 num = parse_ulong(argv[2], argv[0], "num", &err);
 320                 if (err)
 321                         return;
 322
 323                 ext2fs_mark_block_bitmap_range2(test_fs->block_map,
 324                                                 block, num);
 325                 printf("Marking blocks %u to %u\n", block, block + num - 1);
 326                 return;
 327         }
 328
 329         test_result = ext2fs_test_block_bitmap2(test_fs->block_map, block);
 330         op_result = ext2fs_mark_block_bitmap2(test_fs->block_map, block);
 331         printf("Setting block %u, was %s before\n", block, op_result ?
 332                "set" : "clear");
 333         if (!test_result != !op_result)
 334                 com_err(argv[0], 0, "*ERROR* test_result different! (%d, %d)",
 335                         test_result, op_result);
 336 }
 337
 338 void do_clearb(int argc, ss_argv_t argv,
 339                int sci_idx EXT2FS_ATTR((unused)),
 340                void *infop EXT2FS_ATTR((unused)))
 341 {
 342         unsigned int block, num;
 343         int err;
 344         int test_result, op_result;
 345
 346         if (check_fs_open(argv[0]))
 347                 return;
 348
 349         if (argc != 2 && argc != 3) {
 350                 com_err(argv[0], 0, "Usage: clearb <block> [num]");
 351                 return;
 352         }
 353
 354         block = parse_ulong(argv[1], argv[0], "block", &err);
 355         if (err)
 356                 return;
 357
 358         if (argc == 3) {
 359                 num = parse_ulong(argv[2], argv[0], "num", &err);
 360                 if (err)
 361                         return;
 362
 363                 ext2fs_unmark_block_bitmap_range2(test_fs->block_map,
 364                                                 block, num);
 365                 printf("Clearing blocks %u to %u\n", block, block + num - 1);
 366                 return;
 367         }
 368
 369         test_result = ext2fs_test_block_bitmap2(test_fs->block_map, block);
 370         op_result = ext2fs_unmark_block_bitmap2(test_fs->block_map, block);
 371         printf("Clearing block %u, was %s before\n", block, op_result ?
 372                "set" : "clear");
 373         if (!test_result != !op_result)
 374                 com_err(argv[0], 0, "*ERROR* test_result different! (%d, %d)",
 375                         test_result, op_result);
 376 }
 377
 378 void do_testb(int argc, ss_argv_t argv,
 379               int sci_idx EXT2FS_ATTR((unused)),
 380               void *infop EXT2FS_ATTR((unused)))
 381 {
 382         unsigned int block, num;
 383         int err;
 384         int test_result;
 385
 386         if (check_fs_open(argv[0]))
 387                 return;
 388
 389         if (argc != 2 && argc != 3) {
 390                 com_err(argv[0], 0, "Usage: testb <block> [num]");
 391                 return;
 392         }
 393
 394         block = parse_ulong(argv[1], argv[0], "block", &err);
 395         if (err)
 396                 return;
 397
 398         if (argc == 3) {
 399                 num = parse_ulong(argv[2], argv[0], "num", &err);
 400                 if (err)
 401                         return;
 402
 403                 test_result =
 404                         ext2fs_test_block_bitmap_range2(test_fs->block_map,
 405                                                         block, num);
 406                 printf("Blocks %u to %u are %sall clear.\n",
 407                        block, block + num - 1, test_result ? "" : "NOT ");
 408                 return;
 409         }
 410
 411         test_result = ext2fs_test_block_bitmap2(test_fs->block_map, block);
 412         printf("Block %u is %s\n", block, test_result ? "set" : "clear");
 413 }
 414
 415 void do_ffzb(int argc, ss_argv_t argv,
 416              int sci_idx EXT2FS_ATTR((unused)),
 417              void *infop EXT2FS_ATTR((unused)))
 418 {
 419         unsigned int start, end;
 420         int err;
 421         errcode_t retval;
 422         blk64_t out;
 423
 424         if (check_fs_open(argv[0]))
 425                 return;
 426
 427         if (argc != 3 && argc != 3) {
 428                 com_err(argv[0], 0, "Usage: ffzb <start> <end>");
 429                 return;
 430         }
 431
 432         start = parse_ulong(argv[1], argv[0], "start", &err);
 433         if (err)
 434                 return;
 435
 436         end = parse_ulong(argv[2], argv[0], "end", &err);
 437         if (err)
 438                 return;
 439
 440         retval = ext2fs_find_first_zero_block_bitmap2(test_fs->block_map,
 441                                                       start, end, &out);
 442         if (retval) {
 443                 printf("ext2fs_find_first_zero_block_bitmap2() returned %s\n",
 444                        error_message(retval));
 445                 return;
 446         }
 447         printf("First unmarked block is %llu\n", (unsigned long long) out);
 448 }
 449
 450 void do_ffsb(int argc, ss_argv_t argv,
 451              int sci_idx EXT2FS_ATTR((unused)),
 452              void *infop EXT2FS_ATTR((unused)))
 453 {
 454         unsigned int start, end;
 455         int err;
 456         errcode_t retval;
 457         blk64_t out;
 458
 459         if (check_fs_open(argv[0]))
 460                 return;
 461
 462         if (argc != 3 && argc != 3) {
 463                 com_err(argv[0], 0, "Usage: ffsb <start> <end>");
 464                 return;
 465         }
 466
 467         start = parse_ulong(argv[1], argv[0], "start", &err);
 468         if (err)
 469                 return;
 470
 471         end = parse_ulong(argv[2], argv[0], "end", &err);
 472         if (err)
 473                 return;
 474
 475         retval = ext2fs_find_first_set_block_bitmap2(test_fs->block_map,
 476                                                       start, end, &out);
 477         if (retval) {
 478                 printf("ext2fs_find_first_set_block_bitmap2() returned %s\n",
 479                        error_message(retval));
 480                 return;
 481         }
 482         printf("First marked block is %llu\n", (unsigned long long) out);
 483 }
 484
 485
 486 void do_zerob(int argc, ss_argv_t argv,
 487               int sci_idx EXT2FS_ATTR((unused)),
 488               void *infop EXT2FS_ATTR((unused)))
 489 {
 490         if (check_fs_open(argv[0]))
 491                 return;
 492
 493         printf("Clearing block bitmap.\n");
 494         ext2fs_clear_block_bitmap(test_fs->block_map);
 495 }
 496
 497 void do_seti(int argc, ss_argv_t argv,
 498              int sci_idx EXT2FS_ATTR((unused)),
 499              void *infop EXT2FS_ATTR((unused)))
 500 {
 501         unsigned int inode;
 502         int err;
 503         int test_result, op_result;
 504
 505         if (check_fs_open(argv[0]))
 506                 return;
 507
 508         if (argc != 2) {
 509                 com_err(argv[0], 0, "Usage: seti <inode>");
 510                 return;
 511         }
 512
 513         inode = parse_ulong(argv[1], argv[0], "inode", &err);
 514         if (err)
 515                 return;
 516
 517         test_result = ext2fs_test_inode_bitmap2(test_fs->inode_map, inode);
 518         op_result = ext2fs_mark_inode_bitmap2(test_fs->inode_map, inode);
 519         printf("Setting inode %u, was %s before\n", inode, op_result ?
 520                "set" : "clear");
 521         if (!test_result != !op_result) {
 522                 com_err(argv[0], 0, "*ERROR* test_result different! (%d, %d)",
 523                         test_result, op_result);
 524                 exit_status++;
 525         }
 526 }
 527
 528 void do_cleari(int argc, ss_argv_t argv,
 529                int sci_idx EXT2FS_ATTR((unused)),
 530                void *infop EXT2FS_ATTR((unused)))
 531 {
 532         unsigned int inode;
 533         int err;
 534         int test_result, op_result;
 535
 536         if (check_fs_open(argv[0]))
 537                 return;
 538
 539         if (argc != 2) {
 540                 com_err(argv[0], 0, "Usage: clearb <inode>");
 541                 return;
 542         }
 543
 544         inode = parse_ulong(argv[1], argv[0], "inode", &err);
 545         if (err)
 546                 return;
 547
 548         test_result = ext2fs_test_inode_bitmap2(test_fs->inode_map, inode);
 549         op_result = ext2fs_unmark_inode_bitmap2(test_fs->inode_map, inode);
 550         printf("Clearing inode %u, was %s before\n", inode, op_result ?
 551                "set" : "clear");
 552         if (!test_result != !op_result) {
 553                 com_err(argv[0], 0, "*ERROR* test_result different! (%d, %d)",
 554                         test_result, op_result);
 555                 exit_status++;
 556         }
 557 }
 558
 559 void do_testi(int argc, ss_argv_t argv,
 560               int sci_idx EXT2FS_ATTR((unused)),
 561               void *infop EXT2FS_ATTR((unused)))
 562 {
 563         unsigned int inode;
 564         int err;
 565         int test_result;
 566
 567         if (check_fs_open(argv[0]))
 568                 return;
 569
 570         if (argc != 2) {
 571                 com_err(argv[0], 0, "Usage: testb <inode>");
 572                 return;
 573         }
 574
 575         inode = parse_ulong(argv[1], argv[0], "inode", &err);
 576         if (err)
 577                 return;
 578
 579         test_result = ext2fs_test_inode_bitmap2(test_fs->inode_map, inode);
 580         printf("Inode %u is %s\n", inode, test_result ? "set" : "clear");
 581 }
 582
 583 void do_ffzi(int argc, ss_argv_t argv,
 584              int sci_idx EXT2FS_ATTR((unused)),
 585              void *infop EXT2FS_ATTR((unused)))
 586 {
 587         unsigned int start, end;
 588         int err;
 589         errcode_t retval;
 590         ext2_ino_t out;
 591
 592         if (check_fs_open(argv[0]))
 593                 return;
 594
 595         if (argc != 3 && argc != 3) {
 596                 com_err(argv[0], 0, "Usage: ffzi <start> <end>");
 597                 return;
 598         }
 599
 600         start = parse_ulong(argv[1], argv[0], "start", &err);
 601         if (err)
 602                 return;
 603
 604         end = parse_ulong(argv[2], argv[0], "end", &err);
 605         if (err)
 606                 return;
 607
 608         retval = ext2fs_find_first_zero_inode_bitmap2(test_fs->inode_map,
 609                                                       start, end, &out);
 610         if (retval) {
 611                 printf("ext2fs_find_first_zero_inode_bitmap2() returned %s\n",
 612                        error_message(retval));
 613                 return;
 614         }
 615         printf("First unmarked inode is %u\n", out);
 616 }
 617
 618 void do_ffsi(int argc, ss_argv_t argv,
 619              int sci_idx EXT2FS_ATTR((unused)),
 620              void *infop EXT2FS_ATTR((unused)))
 621 {
 622         unsigned int start, end;
 623         int err;
 624         errcode_t retval;
 625         ext2_ino_t out;
 626
 627         if (check_fs_open(argv[0]))
 628                 return;
 629
 630         if (argc != 3 && argc != 3) {
 631                 com_err(argv[0], 0, "Usage: ffsi <start> <end>");
 632                 return;
 633         }
 634
 635         start = parse_ulong(argv[1], argv[0], "start", &err);
 636         if (err)
 637                 return;
 638
 639         end = parse_ulong(argv[2], argv[0], "end", &err);
 640         if (err)
 641                 return;
 642
 643         retval = ext2fs_find_first_set_inode_bitmap2(test_fs->inode_map,
 644                                                      start, end, &out);
 645         if (retval) {
 646                 printf("ext2fs_find_first_set_inode_bitmap2() returned %s\n",
 647                        error_message(retval));
 648                 return;
 649         }
 650         printf("First marked inode is %u\n", out);
 651 }
 652
 653 void do_zeroi(int argc, ss_argv_t argv,
 654               int sci_idx EXT2FS_ATTR((unused)),
 655               void *infop EXT2FS_ATTR((unused)))
 656 {
 657         if (check_fs_open(argv[0]))
 658                 return;
 659
 660         printf("Clearing inode bitmap.\n");
 661         ext2fs_clear_inode_bitmap(test_fs->inode_map);
 662 }
 663
 664 int main(int argc, char **argv)
 665 {
 666         unsigned int    blocks = 128;
 667         unsigned int    inodes = 0;
 668         unsigned int    type = EXT2FS_BMAP64_BITARRAY;
 669         int             c, err, code;
 670         char            *request = (char *)NULL;
 671         char            *cmd_file = 0;
 672         int             sci_idx;
 673         int             flags = EXT2_FLAG_64BITS;
 674
 675         add_error_table(&et_ss_error_table);
 676         add_error_table(&et_ext2_error_table);
 677         while ((c = getopt (argc, argv, "b:i:lt:R:f:")) != EOF) {
 678                 switch (c) {
 679                 case 'b':
 680                         blocks = parse_ulong(optarg, argv[0],
 681                                              "number of blocks", &err);
 682                         if (err)
 683                                 exit(1);
 684                         break;
 685                 case 'i':
 686                         inodes = parse_ulong(optarg, argv[0],
 687                                              "number of blocks", &err);
 688                         if (err)
 689                                 exit(1);
 690                         break;
 691                 case 'l':       /* Legacy bitmaps */
 692                         flags = 0;
 693                         break;
 694                 case 't':
 695                         type = parse_ulong(optarg, argv[0],
 696                                            "bitmap backend type", &err);
 697                         if (err)
 698                                 exit(1);
 699                         break;
 700                 case 'R':
 701                         request = optarg;
 702                         break;
 703                 case 'f':
 704                         cmd_file = optarg;
 705                         break;
 706                 default:
 707                         com_err(argv[0], 0, "Usage: %s [-R request] "
 708                                 "[-f cmd_file]", subsystem_name);
 709                         exit(1);
 710                 }
 711         }
 712
 713         sci_idx = ss_create_invocation(subsystem_name, version,
 714                                        (char *)NULL, &tst_bitmaps_cmds, &code);
 715         if (code) {
 716                 ss_perror(sci_idx, code, "creating invocation");
 717                 exit(1);
 718         }
 719
 720         (void) ss_add_request_table (sci_idx, &ss_std_requests, 1, &code);
 721         if (code) {
 722                 ss_perror(sci_idx, code, "adding standard requests");
 723                 exit (1);
 724         }
 725
 726         printf("%s %s.  Type '?' for a list of commands.\n\n",
 727                subsystem_name, version);
 728
 729         setup_filesystem(argv[0], blocks, inodes, type, flags);
 730
 731         if (request) {
 732                 code = ss_execute_line(sci_idx, request);
 733                 if (code) {
 734                         ss_perror(sci_idx, code, request);
 735                         exit_status++;
 736                 }
 737         } else if (cmd_file) {
 738                 exit_status = source_file(cmd_file, sci_idx);
 739         } else {
 740                 ss_listen(sci_idx);
 741         }
 742
 743         exit(exit_status);
 744 }
 745