git.sur5r.net Git - bacula/bacula/blob - bacula/src/stored/btape.c

   1 /*
   2  *
   3  *   Bacula Tape manipulation program
   4  *
   5  *    Has various tape manipulation commands -- mostly for
   6  *    use in determining how tapes really work.
   7  *
   8  *     Kern Sibbald, April MM
   9  *
  10  *   Note, this program reads stored.conf, and will only
  11  *     talk to devices that are configured.
  12  *
  13  *   Version $Id$
  14  *
  15  */
  16 /*
  17    Copyright (C) 2000-2006 Kern Sibbald
  18
  19    This program is free software; you can redistribute it and/or
  20    modify it under the terms of the GNU General Public License
  21    version 2 as amended with additional clauses defined in the
  22    file LICENSE in the main source directory.
  23
  24    This program is distributed in the hope that it will be useful,
  25    but WITHOUT ANY WARRANTY; without even the implied warranty of
  26    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  27    the file LICENSE for additional details.
  28
  29  */
  30
  31 #include "bacula.h"
  32 #include "stored.h"
  33
  34 /* Dummy functions */
  35 int generate_daemon_event(JCR *jcr, const char *event) { return 1; }
  36
  37 /* External subroutines */
  38 extern void free_config_resources();
  39
  40 /* Exported variables */
  41 int quit = 0;
  42 char buf[100000];
  43 int bsize = TAPE_BSIZE;
  44 char VolName[MAX_NAME_LENGTH];
  45 STORES *me = NULL;                    /* our Global resource */
  46 bool forge_on = false;                /* proceed inspite of I/O errors */
  47 pthread_mutex_t device_release_mutex = PTHREAD_MUTEX_INITIALIZER;
  48 pthread_cond_t wait_device_release = PTHREAD_COND_INITIALIZER;
  49
  50 /*
  51  * If you change the format of the state file,
  52  *  increment this value
  53  */
  54 static uint32_t btape_state_level = 2;
  55
  56 DEVICE *dev = NULL;
  57 DCR *dcr;
  58 DEVRES *device = NULL;
  59
  60
  61 /* Forward referenced subroutines */
  62 static void do_tape_cmds();
  63 static void helpcmd();
  64 static void scancmd();
  65 static void rewindcmd();
  66 static void clearcmd();
  67 static void wrcmd();
  68 static void rrcmd();
  69 static void rbcmd();
  70 static void eodcmd();
  71 static void fillcmd();
  72 static void qfillcmd();
  73 static void statcmd();
  74 static void unfillcmd();
  75 static int flush_block(DEV_BLOCK *block, int dump);
  76 static bool quickie_cb(DCR *dcr, DEV_RECORD *rec);
  77 static bool compare_blocks(DEV_BLOCK *last_block, DEV_BLOCK *block);
  78 static bool my_mount_next_read_volume(DCR *dcr);
  79 static void scan_blocks();
  80 static void set_volume_name(const char *VolName, int volnum);
  81 static void rawfill_cmd();
  82 static void bfill_cmd();
  83 static bool open_the_device();
  84 static void autochangercmd();
  85 static void do_unfill();
  86
  87
  88 /* Static variables */
  89 #define CONFIG_FILE "bacula-sd.conf"
  90 char *configfile = NULL;
  91
  92 #define MAX_CMD_ARGS 30
  93 static POOLMEM *cmd;
  94 static POOLMEM *args;
  95 static char *argk[MAX_CMD_ARGS];
  96 static char *argv[MAX_CMD_ARGS];
  97 static int argc;
  98
  99 static int quickie_count = 0;
 100 static uint64_t write_count = 0;
 101 static BSR *bsr = NULL;
 102 static int signals = TRUE;
 103 static bool ok;
 104 static int stop = 0;
 105 static uint64_t vol_size;
 106 static uint64_t VolBytes;
 107 static time_t now;
 108 static double kbs;
 109 static int32_t file_index;
 110 static int end_of_tape = 0;
 111 static uint32_t LastBlock = 0;
 112 static uint32_t eot_block;
 113 static uint32_t eot_block_len;
 114 static uint32_t eot_FileIndex;
 115 static int dumped = 0;
 116 static DEV_BLOCK *last_block1 = NULL;
 117 static DEV_BLOCK *last_block2 = NULL;
 118 static DEV_BLOCK *last_block = NULL;
 119 static DEV_BLOCK *this_block = NULL;
 120 static DEV_BLOCK *first_block = NULL;
 121 static uint32_t last_file1 = 0;
 122 static uint32_t last_file2 = 0;
 123 static uint32_t last_file = 0;
 124 static uint32_t last_block_num1 = 0;
 125 static uint32_t last_block_num2 = 0;
 126 static uint32_t last_block_num = 0;
 127 static uint32_t BlockNumber = 0;
 128 static bool simple = true;
 129
 130 static const char *VolumeName = NULL;
 131 static int vol_num = 0;
 132
 133 static JCR *jcr = NULL;
 134
 135
 136 static void usage();
 137 static void terminate_btape(int sig);
 138 int get_cmd(const char *prompt);
 139
 140
 141 /*********************************************************************
 142  *
 143  *     Bacula tape testing program
 144  *
 145  */
 146 int main(int margc, char *margv[])
 147 {
 148    int ch, i;
 149    uint32_t x32, y32;
 150    uint64_t x64, y64;
 151    char buf[1000];
 152
 153    setlocale(LC_ALL, "");
 154    bindtextdomain("bacula", LOCALEDIR);
 155    textdomain("bacula");
 156    init_stack_dump();
 157
 158    /* Sanity checks */
 159    if (TAPE_BSIZE % B_DEV_BSIZE != 0 || TAPE_BSIZE / B_DEV_BSIZE == 0) {
 160       Emsg2(M_ABORT, 0, _("Tape block size (%d) not multiple of system size (%d)\n"),
 161          TAPE_BSIZE, B_DEV_BSIZE);
 162    }
 163    if (TAPE_BSIZE != (1 << (ffs(TAPE_BSIZE)-1))) {
 164       Emsg1(M_ABORT, 0, _("Tape block size (%d) is not a power of 2\n"), TAPE_BSIZE);
 165    }
 166    if (sizeof(off_t) < 8) {
 167       Pmsg1(-1, _("\n\n!!!! Warning large disk addressing disabled. off_t=%d should be 8 or more !!!!!\n\n\n"),
 168          sizeof(off_t));
 169    }
 170    x32 = 123456789;
 171    bsnprintf(buf, sizeof(buf), "%u", x32);
 172    i = bsscanf(buf, "%lu", &y32);
 173    if (i != 1 || x32 != y32) {
 174       Pmsg3(-1, _("32 bit printf/scanf problem. i=%d x32=%u y32=%u\n"), i, x32, y32);
 175       exit(1);
 176    }
 177    x64 = 123456789;
 178    x64 = x64 << 32;
 179    x64 += 123456789;
 180    bsnprintf(buf, sizeof(buf), "%" llu, x64);
 181    i = bsscanf(buf, "%llu", &y64);
 182    if (i != 1 || x64 != y64) {
 183       Pmsg3(-1, _("64 bit printf/scanf problem. i=%d x64=%" llu " y64=%" llu "\n"),
 184             i, x64, y64);
 185       exit(1);
 186    }
 187
 188    printf(_("Tape block granularity is %d bytes.\n"), TAPE_BSIZE);
 189
 190    working_directory = "/tmp";
 191    my_name_is(margc, margv, "btape");
 192    init_msg(NULL, NULL);
 193
 194    OSDependentInit();
 195
 196    while ((ch = getopt(margc, margv, "b:c:d:psv?")) != -1) {
 197       switch (ch) {
 198       case 'b':                    /* bootstrap file */
 199          bsr = parse_bsr(NULL, optarg);
 200 //       dump_bsr(bsr, true);
 201          break;
 202
 203       case 'c':                    /* specify config file */
 204          if (configfile != NULL) {
 205             free(configfile);
 206          }
 207          configfile = bstrdup(optarg);
 208          break;
 209
 210       case 'd':                    /* set debug level */
 211          debug_level = atoi(optarg);
 212          if (debug_level <= 0) {
 213             debug_level = 1;
 214          }
 215          break;
 216
 217       case 'p':
 218          forge_on = true;
 219          break;
 220
 221       case 's':
 222          signals = false;
 223          break;
 224
 225       case 'v':
 226          verbose++;
 227          break;
 228
 229       case '?':
 230       default:
 231          helpcmd();
 232          exit(0);
 233
 234       }
 235    }
 236    margc -= optind;
 237    margv += optind;
 238
 239    cmd = get_pool_memory(PM_FNAME);
 240    args = get_pool_memory(PM_FNAME);
 241
 242    if (signals) {
 243       init_signals(terminate_btape);
 244    }
 245
 246    if (configfile == NULL) {
 247       configfile = bstrdup(CONFIG_FILE);
 248    }
 249
 250    daemon_start_time = time(NULL);
 251
 252    parse_config(configfile);
 253
 254
 255    /* See if we can open a device */
 256    if (margc == 0) {
 257       Pmsg0(000, _("No archive name specified.\n"));
 258       usage();
 259       exit(1);
 260    } else if (margc != 1) {
 261       Pmsg0(000, _("Improper number of arguments specified.\n"));
 262       usage();
 263       exit(1);
 264    }
 265
 266    jcr = setup_jcr("btape", margv[0], bsr, NULL, 0); /* write */
 267    if (!jcr) {
 268       exit(1);
 269    }
 270    dev = jcr->dcr->dev;
 271    if (!dev) {
 272       exit(1);
 273    }
 274    if (dev->is_dvd()) {
 275       Pmsg0(000, _("btape does not work with DVD storage.\n"));
 276       usage();
 277       exit(1);
 278    }
 279    if (!dev->is_tape()) {
 280       Pmsg0(000, _("btape only works with tape storage.\n"));
 281       usage();
 282       exit(1);
 283    }
 284    dcr = jcr->dcr;
 285    if (!open_the_device()) {
 286       goto terminate;
 287    }
 288
 289    Dmsg0(200, "Do tape commands\n");
 290    do_tape_cmds();
 291
 292 terminate:
 293    terminate_btape(0);
 294    return 0;
 295 }
 296
 297 static void terminate_btape(int stat)
 298 {
 299
 300    sm_check(__FILE__, __LINE__, false);
 301    if (configfile) {
 302       free(configfile);
 303    }
 304    free_config_resources();
 305    if (args) {
 306       free_pool_memory(args);
 307       args = NULL;
 308    }
 309    if (cmd) {
 310       free_pool_memory(cmd);
 311       cmd = NULL;
 312    }
 313
 314    if (bsr) {
 315       free_bsr(bsr);
 316    }
 317
 318    free_jcr(jcr);
 319    jcr = NULL;
 320
 321    if (dev) {
 322       dev->term();
 323    }
 324
 325    free_volume_list();
 326
 327    if (debug_level > 10)
 328       print_memory_pool_stats();
 329
 330    if (this_block) {
 331       free_block(this_block);
 332    }
 333
 334    stop_watchdog();
 335    term_msg();
 336    close_memory_pool();               /* free memory in pool */
 337    term_last_jobs_list();
 338
 339    sm_dump(false);
 340    exit(stat);
 341 }
 342
 343 static bool open_the_device()
 344 {
 345    DEV_BLOCK *block;
 346
 347    block = new_block(dev);
 348    lock_device(dev);
 349    Dmsg1(200, "Opening device %s\n", dcr->VolumeName);
 350    if (dev->open(dcr, OPEN_READ_WRITE) < 0) {
 351       Emsg1(M_FATAL, 0, _("dev open failed: %s\n"), dev->errmsg);
 352       unlock_device(dev);
 353       free_block(block);
 354       return false;
 355    }
 356    Pmsg1(000, _("open device %s: OK\n"), dev->print_name());
 357    dev->set_append();                 /* put volume in append mode */
 358    unlock_device(dev);
 359    free_block(block);
 360    return true;
 361 }
 362
 363
 364 void quitcmd()
 365 {
 366    quit = 1;
 367 }
 368
 369 /*
 370  * Write a label to the tape
 371  */
 372 static void labelcmd()
 373 {
 374    if (VolumeName) {
 375       pm_strcpy(cmd, VolumeName);
 376    } else {
 377       if (!get_cmd(_("Enter Volume Name: "))) {
 378          return;
 379       }
 380    }
 381
 382    if (!dev->is_open()) {
 383       if (!first_open_device(dcr)) {
 384          Pmsg1(0, _("Device open failed. ERR=%s\n"), dev->bstrerror());
 385       }
 386    }
 387    dev->rewind(dcr);
 388    dev->weof(1);
 389    write_new_volume_label_to_dev(dcr, cmd, "Default", false,/*no relabel*/ true /* label dvd now */);
 390    Pmsg1(-1, _("Wrote Volume label for volume \"%s\".\n"), cmd);
 391 }
 392
 393 /*
 394  * Read the tape label
 395  */
 396 static void readlabelcmd()
 397 {
 398    int save_debug_level = debug_level;
 399    int stat;
 400
 401    stat = read_dev_volume_label(dcr);
 402    switch (stat) {
 403    case VOL_NO_LABEL:
 404       Pmsg0(0, _("Volume has no label.\n"));
 405       break;
 406    case VOL_OK:
 407       Pmsg0(0, _("Volume label read correctly.\n"));
 408       break;
 409    case VOL_IO_ERROR:
 410       Pmsg1(0, _("I/O error on device: ERR=%s"), dev->bstrerror());
 411       break;
 412    case VOL_NAME_ERROR:
 413       Pmsg0(0, _("Volume name error\n"));
 414       break;
 415    case VOL_CREATE_ERROR:
 416       Pmsg1(0, _("Error creating label. ERR=%s"), dev->bstrerror());
 417       break;
 418    case VOL_VERSION_ERROR:
 419       Pmsg0(0, _("Volume version error.\n"));
 420       break;
 421    case VOL_LABEL_ERROR:
 422       Pmsg0(0, _("Bad Volume label type.\n"));
 423       break;
 424    default:
 425       Pmsg0(0, _("Unknown error.\n"));
 426       break;
 427    }
 428
 429    debug_level = 20;
 430    dump_volume_label(dev);
 431    debug_level = save_debug_level;
 432 }
 433
 434
 435 /*
 436  * Load the tape should have prevously been taken
 437  * off line, otherwise this command is not necessary.
 438  */
 439 static void loadcmd()
 440 {
 441
 442    if (!load_dev(dev)) {
 443       Pmsg1(0, _("Bad status from load. ERR=%s\n"), dev->bstrerror());
 444    } else
 445       Pmsg1(0, _("Loaded %s\n"), dev->print_name());
 446 }
 447
 448 /*
 449  * Rewind the tape.
 450  */
 451 static void rewindcmd()
 452 {
 453    if (!dev->rewind(dcr)) {
 454       Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
 455       dev->clrerror(-1);
 456    } else {
 457       Pmsg1(0, _("Rewound %s\n"), dev->print_name());
 458    }
 459 }
 460
 461 /*
 462  * Clear any tape error
 463  */
 464 static void clearcmd()
 465 {
 466    dev->clrerror(-1);
 467 }
 468
 469 /*
 470  * Write and end of file on the tape
 471  */
 472 static void weofcmd()
 473 {
 474    int num = 1;
 475    if (argc > 1) {
 476       num = atoi(argk[1]);
 477    }
 478    if (num <= 0) {
 479       num = 1;
 480    }
 481
 482    if (!dev->weof(num)) {
 483       Pmsg1(0, _("Bad status from weof. ERR=%s\n"), dev->bstrerror());
 484       return;
 485    } else {
 486       if (num==1) {
 487          Pmsg1(0, _("Wrote 1 EOF to %s\n"), dev->print_name());
 488       }
 489       else {
 490          Pmsg2(0, _("Wrote %d EOFs to %s\n"), num, dev->print_name());
 491       }
 492    }
 493 }
 494
 495
 496 /* Go to the end of the medium -- raw command
 497  * The idea was orginally that the end of the Bacula
 498  * medium would be flagged differently. This is not
 499  * currently the case. So, this is identical to the
 500  * eodcmd().
 501  */
 502 static void eomcmd()
 503 {
 504    if (!dev->eod(dcr)) {
 505       Pmsg1(0, "%s", dev->bstrerror());
 506       return;
 507    } else {
 508       Pmsg0(0, _("Moved to end of medium.\n"));
 509    }
 510 }
 511
 512 /*
 513  * Go to the end of the medium (either hardware determined
 514  *  or defined by two eofs.
 515  */
 516 static void eodcmd()
 517 {
 518    eomcmd();
 519 }
 520
 521 /*
 522  * Backspace file
 523  */
 524 static void bsfcmd()
 525 {
 526    int num = 1;
 527    if (argc > 1) {
 528       num = atoi(argk[1]);
 529    }
 530    if (num <= 0) {
 531       num = 1;
 532    }
 533
 534    if (!dev->bsf(num)) {
 535       Pmsg1(0, _("Bad status from bsf. ERR=%s\n"), dev->bstrerror());
 536    } else {
 537       Pmsg2(0, _("Backspaced %d file%s.\n"), num, num==1?"":"s");
 538    }
 539 }
 540
 541 /*
 542  * Backspace record
 543  */
 544 static void bsrcmd()
 545 {
 546    int num = 1;
 547    if (argc > 1) {
 548       num = atoi(argk[1]);
 549    }
 550    if (num <= 0) {
 551       num = 1;
 552    }
 553    if (!dev->bsr(num)) {
 554       Pmsg1(0, _("Bad status from bsr. ERR=%s\n"), dev->bstrerror());
 555    } else {
 556       Pmsg2(0, _("Backspaced %d record%s.\n"), num, num==1?"":"s");
 557    }
 558 }
 559
 560 /*
 561  * List device capabilities as defined in the
 562  *  stored.conf file.
 563  */
 564 static void capcmd()
 565 {
 566    printf(_("Configured device capabilities:\n"));
 567    printf("%sEOF ", dev->capabilities & CAP_EOF ? "" : "!");
 568    printf("%sBSR ", dev->capabilities & CAP_BSR ? "" : "!");
 569    printf("%sBSF ", dev->capabilities & CAP_BSF ? "" : "!");
 570    printf("%sFSR ", dev->capabilities & CAP_FSR ? "" : "!");
 571    printf("%sFSF ", dev->capabilities & CAP_FSF ? "" : "!");
 572    printf("%sFASTFSF ", dev->capabilities & CAP_FASTFSF ? "" : "!");
 573    printf("%sBSFATEOM ", dev->capabilities & CAP_BSFATEOM ? "" : "!");
 574    printf("%sEOM ", dev->capabilities & CAP_EOM ? "" : "!");
 575    printf("%sREM ", dev->capabilities & CAP_REM ? "" : "!");
 576    printf("%sRACCESS ", dev->capabilities & CAP_RACCESS ? "" : "!");
 577    printf("%sAUTOMOUNT ", dev->capabilities & CAP_AUTOMOUNT ? "" : "!");
 578    printf("%sLABEL ", dev->capabilities & CAP_LABEL ? "" : "!");
 579    printf("%sANONVOLS ", dev->capabilities & CAP_ANONVOLS ? "" : "!");
 580    printf("%sALWAYSOPEN ", dev->capabilities & CAP_ALWAYSOPEN ? "" : "!");
 581    printf("%sMTIOCGET ", dev->capabilities & CAP_MTIOCGET ? "" : "!");
 582    printf("\n");
 583
 584    printf(_("Device status:\n"));
 585    printf("%sOPENED ", dev->is_open() ? "" : "!");
 586    printf("%sTAPE ", dev->is_tape() ? "" : "!");
 587    printf("%sLABEL ", dev->is_labeled() ? "" : "!");
 588    printf("%sMALLOC ", dev->state & ST_MALLOC ? "" : "!");
 589    printf("%sAPPEND ", dev->can_append() ? "" : "!");
 590    printf("%sREAD ", dev->can_read() ? "" : "!");
 591    printf("%sEOT ", dev->at_eot() ? "" : "!");
 592    printf("%sWEOT ", dev->state & ST_WEOT ? "" : "!");
 593    printf("%sEOF ", dev->at_eof() ? "" : "!");
 594    printf("%sNEXTVOL ", dev->state & ST_NEXTVOL ? "" : "!");
 595    printf("%sSHORT ", dev->state & ST_SHORT ? "" : "!");
 596    printf("\n");
 597
 598    printf(_("Device parameters:\n"));
 599    printf("Device name: %s\n", dev->dev_name);
 600    printf("File=%u block=%u\n", dev->file, dev->block_num);
 601    printf("Min block=%u Max block=%u\n", dev->min_block_size, dev->max_block_size);
 602
 603    printf(_("Status:\n"));
 604    statcmd();
 605
 606 }
 607
 608 /*
 609  * Test writting larger and larger records.
 610  * This is a torture test for records.
 611  */
 612 static void rectestcmd()
 613 {
 614    DEV_BLOCK *block;
 615    DEV_RECORD *rec;
 616    int i, blkno = 0;
 617
 618    Pmsg0(0, _("Test writting larger and larger records.\n"
 619 "This is a torture test for records.\nI am going to write\n"
 620 "larger and larger records. It will stop when the record size\n"
 621 "plus the header exceeds the block size (by default about 64K)\n"));
 622
 623
 624    get_cmd(_("Do you want to continue? (y/n): "));
 625    if (cmd[0] != 'y') {
 626       Pmsg0(000, _("Command aborted.\n"));
 627       return;
 628    }
 629
 630    sm_check(__FILE__, __LINE__, false);
 631    block = new_block(dev);
 632    rec = new_record();
 633
 634    for (i=1; i<500000; i++) {
 635       rec->data = check_pool_memory_size(rec->data, i);
 636       memset(rec->data, i & 0xFF, i);
 637       rec->data_len = i;
 638       sm_check(__FILE__, __LINE__, false);
 639       if (write_record_to_block(block, rec)) {
 640          empty_block(block);
 641          blkno++;
 642          Pmsg2(0, _("Block %d i=%d\n"), blkno, i);
 643       } else {
 644          break;
 645       }
 646       sm_check(__FILE__, __LINE__, false);
 647    }
 648    free_record(rec);
 649    free_block(block);
 650    sm_check(__FILE__, __LINE__, false);
 651 }
 652
 653 /*
 654  * This test attempts to re-read a block written by Bacula
 655  *   normally at the end of the tape. Bacula will then back up
 656  *   over the two eof marks, backup over the record and reread
 657  *   it to make sure it is valid.  Bacula can skip this validation
 658  *   if you set "Backward space record = no"
 659  */
 660 static int re_read_block_test()
 661 {
 662    DEV_BLOCK *block = dcr->block;
 663    DEV_RECORD *rec;
 664    int stat = 0;
 665    int len;
 666
 667    if (!(dev->capabilities & CAP_BSR)) {
 668       Pmsg0(-1, _("Skipping read backwards test because BSR turned off.\n"));
 669       return 0;
 670    }
 671
 672    Pmsg0(-1, _("\n=== Write, backup, and re-read test ===\n\n"
 673       "I'm going to write three records and an EOF\n"
 674       "then backup over the EOF and re-read the last record.\n"
 675       "Bacula does this after writing the last block on the\n"
 676       "tape to verify that the block was written correctly.\n\n"
 677       "This is not an *essential* feature ...\n\n"));
 678    rewindcmd();
 679    empty_block(block);
 680    rec = new_record();
 681    rec->data = check_pool_memory_size(rec->data, block->buf_len);
 682    len = rec->data_len = block->buf_len-100;
 683    memset(rec->data, 1, rec->data_len);
 684    if (!write_record_to_block(block, rec)) {
 685       Pmsg0(0, _("Error writing record to block.\n"));
 686       goto bail_out;
 687    }
 688    if (!write_block_to_dev(dcr)) {
 689       Pmsg0(0, _("Error writing block to device.\n"));
 690       goto bail_out;
 691    } else {
 692       Pmsg1(0, _("Wrote first record of %d bytes.\n"), rec->data_len);
 693    }
 694    memset(rec->data, 2, rec->data_len);
 695    if (!write_record_to_block(block, rec)) {
 696       Pmsg0(0, _("Error writing record to block.\n"));
 697       goto bail_out;
 698    }
 699    if (!write_block_to_dev(dcr)) {
 700       Pmsg0(0, _("Error writing block to device.\n"));
 701       goto bail_out;
 702    } else {
 703       Pmsg1(0, _("Wrote second record of %d bytes.\n"), rec->data_len);
 704    }
 705    memset(rec->data, 3, rec->data_len);
 706    if (!write_record_to_block(block, rec)) {
 707       Pmsg0(0, _("Error writing record to block.\n"));
 708       goto bail_out;
 709    }
 710    if (!write_block_to_dev(dcr)) {
 711       Pmsg0(0, _("Error writing block to device.\n"));
 712       goto bail_out;
 713    } else {
 714       Pmsg1(0, _("Wrote third record of %d bytes.\n"), rec->data_len);
 715    }
 716    weofcmd();
 717    if (dev_cap(dev, CAP_TWOEOF)) {
 718       weofcmd();
 719    }
 720    if (!dev->bsf(1)) {
 721       Pmsg1(0, _("Backspace file failed! ERR=%s\n"), dev->bstrerror());
 722       goto bail_out;
 723    }
 724    if (dev_cap(dev, CAP_TWOEOF)) {
 725       if (!dev->bsf(1)) {
 726          Pmsg1(0, _("Backspace file failed! ERR=%s\n"), dev->bstrerror());
 727          goto bail_out;
 728       }
 729    }
 730    Pmsg0(0, _("Backspaced over EOF OK.\n"));
 731    if (!dev->bsr(1)) {
 732       Pmsg1(0, _("Backspace record failed! ERR=%s\n"), dev->bstrerror());
 733       goto bail_out;
 734    }
 735    Pmsg0(0, _("Backspace record OK.\n"));
 736    if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
 737       berrno be;
 738       Pmsg1(0, _("Read block failed! ERR=%s\n"), be.strerror(dev->dev_errno));
 739       goto bail_out;
 740    }
 741    memset(rec->data, 0, rec->data_len);
 742    if (!read_record_from_block(block, rec)) {
 743       berrno be;
 744       Pmsg1(0, _("Read block failed! ERR=%s\n"), be.strerror(dev->dev_errno));
 745       goto bail_out;
 746    }
 747    for (int i=0; i<len; i++) {
 748       if (rec->data[i] != 3) {
 749          Pmsg0(0, _("Bad data in record. Test failed!\n"));
 750          goto bail_out;
 751       }
 752    }
 753    Pmsg0(0, _("\nBlock re-read correct. Test succeeded!\n"));
 754    Pmsg0(-1, _("=== End Write, backup, and re-read test ===\n\n"));
 755
 756    stat = 1;
 757
 758 bail_out:
 759    free_record(rec);
 760    if (stat == 0) {
 761       Pmsg0(0, _("This is not terribly serious since Bacula only uses\n"
 762                  "this function to verify the last block written to the\n"
 763                  "tape. Bacula will skip the last block verification\n"
 764                  "if you add:\n\n"
 765                   "Backward Space Record = No\n\n"
 766                   "to your Storage daemon's Device resource definition.\n"));
 767    }
 768    return stat;
 769 }
 770
 771
 772 /*
 773  * This test writes Bacula blocks to the tape in
 774  *   several files. It then rewinds the tape and attepts
 775  *   to read these blocks back checking the data.
 776  */
 777 static int write_read_test()
 778 {
 779    DEV_BLOCK *block;
 780    DEV_RECORD *rec;
 781    int stat = 0;
 782    int len, i, j;
 783    int *p;
 784
 785    Pmsg0(-1, _("\n=== Write, rewind, and re-read test ===\n\n"
 786       "I'm going to write 1000 records and an EOF\n"
 787       "then write 1000 records and an EOF, then rewind,\n"
 788       "and re-read the data to verify that it is correct.\n\n"
 789       "This is an *essential* feature ...\n\n"));
 790    block = dcr->block;
 791    rec = new_record();
 792    if (!dev->rewind(dcr)) {
 793       Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
 794       goto bail_out;
 795    }
 796    rec->data = check_pool_memory_size(rec->data, block->buf_len);
 797    rec->data_len = block->buf_len-100;
 798    len = rec->data_len/sizeof(i);
 799    for (i=1; i<=1000; i++) {
 800       p = (int *)rec->data;
 801       for (j=0; j<len; j++) {
 802          *p++ = i;
 803       }
 804       if (!write_record_to_block(block, rec)) {
 805          Pmsg0(0, _("Error writing record to block.\n"));
 806          goto bail_out;
 807       }
 808       if (!write_block_to_dev(dcr)) {
 809          Pmsg0(0, _("Error writing block to device.\n"));
 810          goto bail_out;
 811       }
 812    }
 813    Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
 814    weofcmd();
 815    for (i=1001; i<=2000; i++) {
 816       p = (int *)rec->data;
 817       for (j=0; j<len; j++) {
 818          *p++ = i;
 819       }
 820       if (!write_record_to_block(block, rec)) {
 821          Pmsg0(0, _("Error writing record to block.\n"));
 822          goto bail_out;
 823       }
 824       if (!write_block_to_dev(dcr)) {
 825          Pmsg0(0, _("Error writing block to device.\n"));
 826          goto bail_out;
 827       }
 828    }
 829    Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
 830    weofcmd();
 831    if (dev_cap(dev, CAP_TWOEOF)) {
 832       weofcmd();
 833    }
 834    if (!dev->rewind(dcr)) {
 835       Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
 836       goto bail_out;
 837    } else {
 838       Pmsg0(0, _("Rewind OK.\n"));
 839    }
 840    for (i=1; i<=2000; i++) {
 841 read_again:
 842       if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
 843          berrno be;
 844          if (dev_state(dev, ST_EOF)) {
 845             Pmsg0(-1, _("Got EOF on tape.\n"));
 846             if (i == 1001) {
 847                goto read_again;
 848             }
 849          }
 850          Pmsg2(0, _("Read block %d failed! ERR=%s\n"), i, be.strerror(dev->dev_errno));
 851          goto bail_out;
 852       }
 853       memset(rec->data, 0, rec->data_len);
 854       if (!read_record_from_block(block, rec)) {
 855          berrno be;
 856          Pmsg2(0, _("Read record failed. Block %d! ERR=%s\n"), i, be.strerror(dev->dev_errno));
 857          goto bail_out;
 858       }
 859       p = (int *)rec->data;
 860       for (j=0; j<len; j++) {
 861          if (*p != i) {
 862             Pmsg3(0, _("Bad data in record. Expected %d, got %d at byte %d. Test failed!\n"),
 863                i, *p, j);
 864             goto bail_out;
 865          }
 866          p++;
 867       }
 868       if (i == 1000 || i == 2000) {
 869          Pmsg0(-1, _("1000 blocks re-read correctly.\n"));
 870       }
 871    }
 872    Pmsg0(-1, _("=== Test Succeeded. End Write, rewind, and re-read test ===\n\n"));
 873    stat = 1;
 874
 875 bail_out:
 876    free_record(rec);
 877    return stat;
 878 }
 879
 880 /*
 881  * This test writes Bacula blocks to the tape in
 882  *   several files. It then rewinds the tape and attepts
 883  *   to read these blocks back checking the data.
 884  */
 885 static int position_test()
 886 {
 887    DEV_BLOCK *block = dcr->block;
 888    DEV_RECORD *rec;
 889    int stat = 0;
 890    int len, i, j;
 891    bool ok = true;
 892    int recno = 0;
 893    int file = 0, blk = 0;
 894    int *p;
 895    bool got_eof = false;
 896
 897    Pmsg0(-1, _("\n=== Write, rewind, and position test ===\n\n"
 898       "I'm going to write 1000 records and an EOF\n"
 899       "then write 1000 records and an EOF, then rewind,\n"
 900       "and position to a few blocks and verify that it is correct.\n\n"
 901       "This is an *essential* feature ...\n\n"));
 902    empty_block(block);
 903    rec = new_record();
 904    if (!dev->rewind(dcr)) {
 905       Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
 906       goto bail_out;
 907    }
 908    rec->data = check_pool_memory_size(rec->data, block->buf_len);
 909    rec->data_len = block->buf_len-100;
 910    len = rec->data_len/sizeof(i);
 911    for (i=1; i<=1000; i++) {
 912       p = (int *)rec->data;
 913       for (j=0; j<len; j++) {
 914          *p++ = i;
 915       }
 916       if (!write_record_to_block(block, rec)) {
 917          Pmsg0(0, _("Error writing record to block.\n"));
 918          goto bail_out;
 919       }
 920       if (!write_block_to_dev(dcr)) {
 921          Pmsg0(0, _("Error writing block to device.\n"));
 922          goto bail_out;
 923       }
 924    }
 925    Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
 926    weofcmd();
 927    for (i=1001; i<=2000; i++) {
 928       p = (int *)rec->data;
 929       for (j=0; j<len; j++) {
 930          *p++ = i;
 931       }
 932       if (!write_record_to_block(block, rec)) {
 933          Pmsg0(0, _("Error writing record to block.\n"));
 934          goto bail_out;
 935       }
 936       if (!write_block_to_dev(dcr)) {
 937          Pmsg0(0, _("Error writing block to device.\n"));
 938          goto bail_out;
 939       }
 940    }
 941    Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
 942    weofcmd();
 943    if (dev_cap(dev, CAP_TWOEOF)) {
 944       weofcmd();
 945    }
 946    if (!dev->rewind(dcr)) {
 947       Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
 948       goto bail_out;
 949    } else {
 950       Pmsg0(0, _("Rewind OK.\n"));
 951    }
 952
 953    while(ok) {
 954       /* Set up next item to read based on where we are */
 955       switch (recno) {
 956       case 0:
 957          recno = 5;
 958          file = 0;
 959          blk = 4;
 960          break;
 961       case 5:
 962          recno = 201;
 963          file = 0;
 964          blk = 200;
 965          break;
 966       case 201:
 967          recno = 1000;
 968          file = 0;
 969          blk = 999;
 970          break;
 971       case 1000:
 972          recno = 1001;
 973          file = 1;
 974          blk = 0;
 975          break;
 976       case 1001:
 977          recno = 1601;
 978          file = 1;
 979          blk = 600;
 980          break;
 981       case 1601:
 982          recno = 2000;
 983          file = 1;
 984          blk = 999;
 985          break;
 986       case 2000:
 987          ok = false;
 988          continue;
 989       }
 990       Pmsg2(-1, _("Reposition to file:block %d:%d\n"), file, blk);
 991       if (!dev->reposition(dcr, file, blk)) {
 992          Pmsg0(0, _("Reposition error.\n"));
 993          goto bail_out;
 994       }
 995 read_again:
 996       if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
 997          berrno be;
 998          if (dev_state(dev, ST_EOF)) {
 999             Pmsg0(-1, _("Got EOF on tape.\n"));
1000             if (!got_eof) {
1001                got_eof = true;
1002                goto read_again;
1003             }
1004          }
1005          Pmsg4(0, _("Read block %d failed! file=%d blk=%d. ERR=%s\n\n"),
1006             recno, file, blk, be.strerror(dev->dev_errno));
1007          Pmsg0(0, _("This may be because the tape drive block size is not\n"
1008                     " set to variable blocking as normally used by Bacula.\n"
1009                     " Please see the Tape Testing chapter in the manual and \n"
1010                     " look for using mt with defblksize and setoptions\n"
1011                     "If your tape drive block size is correct, then perhaps\n"
1012                     " your SCSI driver is *really* stupid and does not\n"
1013                     " correctly report the file:block after a FSF. In this\n"
1014                     " case try setting:\n"
1015                     "    Fast Forward Space File = no\n"
1016                     " in your Device resource.\n"));
1017
1018          goto bail_out;
1019       }
1020       memset(rec->data, 0, rec->data_len);
1021       if (!read_record_from_block(block, rec)) {
1022          berrno be;
1023          Pmsg1(0, _("Read record failed! ERR=%s\n"), be.strerror(dev->dev_errno));
1024          goto bail_out;
1025       }
1026       p = (int *)rec->data;
1027       for (j=0; j<len; j++) {
1028          if (p[j] != recno) {
1029             Pmsg3(0, _("Bad data in record. Expected %d, got %d at byte %d. Test failed!\n"),
1030                recno, p[j], j);
1031             goto bail_out;
1032          }
1033       }
1034       Pmsg1(-1, _("Block %d re-read correctly.\n"), recno);
1035    }
1036    Pmsg0(-1, _("=== Test Succeeded. End Write, rewind, and re-read test ===\n\n"));
1037    stat = 1;
1038
1039 bail_out:
1040    free_record(rec);
1041    return stat;
1042 }
1043
1044
1045
1046
1047 /*
1048  * This test writes some records, then writes an end of file,
1049  *   rewinds the tape, moves to the end of the data and attepts
1050  *   to append to the tape.  This function is essential for
1051  *   Bacula to be able to write multiple jobs to the tape.
1052  */
1053 static int append_test()
1054 {
1055    Pmsg0(-1, _("\n\n=== Append files test ===\n\n"
1056                "This test is essential to Bacula.\n\n"
1057 "I'm going to write one record  in file 0,\n"
1058 "                   two records in file 1,\n"
1059 "             and three records in file 2\n\n"));
1060    argc = 1;
1061    rewindcmd();
1062    wrcmd();
1063    weofcmd();      /* end file 0 */
1064    wrcmd();
1065    wrcmd();
1066    weofcmd();      /* end file 1 */
1067    wrcmd();
1068    wrcmd();
1069    wrcmd();
1070    weofcmd();     /* end file 2 */
1071    if (dev_cap(dev, CAP_TWOEOF)) {
1072       weofcmd();
1073    }
1074    dev->close();              /* release device */
1075    if (!open_the_device()) {
1076       return -1;
1077    }
1078    rewindcmd();
1079    Pmsg0(0, _("Now moving to end of medium.\n"));
1080    eodcmd();
1081    Pmsg2(-1, _("We should be in file 3. I am at file %d. %s\n"),
1082       dev->file, dev->file == 3 ? _("This is correct!") : _("This is NOT correct!!!!"));
1083
1084    if (dev->file != 3) {
1085       return -1;
1086    }
1087
1088    Pmsg0(-1, _("\nNow the important part, I am going to attempt to append to the tape.\n\n"));
1089    wrcmd();
1090    weofcmd();
1091    if (dev_cap(dev, CAP_TWOEOF)) {
1092       weofcmd();
1093    }
1094    rewindcmd();
1095    Pmsg0(-1, _("Done appending, there should be no I/O errors\n\n"));
1096    Pmsg0(-1, _("Doing Bacula scan of blocks:\n"));
1097    scan_blocks();
1098    Pmsg0(-1, _("End scanning the tape.\n"));
1099    Pmsg2(-1, _("We should be in file 4. I am at file %d. %s\n"),
1100       dev->file, dev->file == 4 ? _("This is correct!") : _("This is NOT correct!!!!"));
1101
1102    if (dev->file != 4) {
1103       return -2;
1104    }
1105    return 1;
1106 }
1107
1108
1109 /*
1110  * This test exercises the autochanger
1111  */
1112 static int autochanger_test()
1113 {
1114    POOLMEM *results, *changer;
1115    int slot, status, loaded;
1116    int timeout = dcr->device->max_changer_wait;
1117    int sleep_time = 0;
1118
1119    Dmsg1(100, "Max changer wait = %d sec\n", timeout);
1120    if (!dev_cap(dev, CAP_AUTOCHANGER)) {
1121       return 1;
1122    }
1123    if (!(dcr->device && dcr->device->changer_name && dcr->device->changer_command)) {
1124       Pmsg0(-1, _("\nAutochanger enabled, but no name or no command device specified.\n"));
1125       return 1;
1126    }
1127
1128    Pmsg0(-1, _("\nAh, I see you have an autochanger configured.\n"
1129              "To test the autochanger you must have a blank tape\n"
1130              " that I can write on in Slot 1.\n"));
1131    if (!get_cmd(_("\nDo you wish to continue with the Autochanger test? (y/n): "))) {
1132       return 0;
1133    }
1134    if (cmd[0] != 'y' && cmd[0] != 'Y') {
1135       return 0;
1136    }
1137
1138    Pmsg0(-1, _("\n\n=== Autochanger test ===\n\n"));
1139
1140    results = get_pool_memory(PM_MESSAGE);
1141    changer = get_pool_memory(PM_FNAME);
1142
1143 try_again:
1144    slot = 1;
1145    dcr->VolCatInfo.Slot = slot;
1146    /* Find out what is loaded, zero means device is unloaded */
1147    Pmsg0(-1, _("3301 Issuing autochanger \"loaded\" command.\n"));
1148    changer = edit_device_codes(dcr, changer,
1149                 dcr->device->changer_command, "loaded");
1150    status = run_program(changer, timeout, results);
1151    Dmsg3(100, "run_prog: %s stat=%d result=\"%s\"\n", changer, status, results);
1152    if (status == 0) {
1153       loaded = atoi(results);
1154    } else {
1155       berrno be;
1156       Pmsg1(-1, _("3991 Bad autochanger command: %s\n"), changer);
1157       Pmsg2(-1, _("3991 result=\"%s\": ERR=%s\n"), results, be.strerror(status));
1158       goto bail_out;
1159    }
1160    if (loaded) {
1161       Pmsg1(-1, _("Slot %d loaded. I am going to unload it.\n"), loaded);
1162    } else {
1163       Pmsg0(-1, _("Nothing loaded in the drive. OK.\n"));
1164    }
1165    Dmsg1(100, "Results from loaded query=%s\n", results);
1166    if (loaded) {
1167       dcr->VolCatInfo.Slot = loaded;
1168       /* We are going to load a new tape, so close the device */
1169       dev->close();
1170       Pmsg2(-1, _("3302 Issuing autochanger \"unload %d %d\" command.\n"),
1171          loaded, dev->drive_index);
1172       changer = edit_device_codes(dcr, changer,
1173                    dcr->device->changer_command, "unload");
1174       status = run_program(changer, timeout, results);
1175       Pmsg2(-1, _("unload status=%s %d\n"), status==0?_("OK"):_("Bad"), status);
1176       if (status != 0) {
1177          berrno be;
1178          Pmsg1(-1, _("3992 Bad autochanger command: %s\n"), changer);
1179          Pmsg2(-1, _("3992 result=\"%s\": ERR=%s\n"), results, be.strerror(status));
1180       }
1181    }
1182
1183    /*
1184     * Load the Slot 1
1185     */
1186
1187    slot = 1;
1188    dcr->VolCatInfo.Slot = slot;
1189    Pmsg2(-1, _("3303 Issuing autochanger \"load %d %d\" command.\n"),
1190       slot, dev->drive_index);
1191    changer = edit_device_codes(dcr, changer,
1192                 dcr->device->changer_command, "load");
1193    Dmsg1(100, "Changer=%s\n", changer);
1194    dev->close();
1195    status = run_program(changer, timeout, results);
1196    if (status == 0) {
1197       Pmsg2(-1,  _("3303 Autochanger \"load %d %d\" status is OK.\n"),
1198          slot, dev->drive_index);
1199    } else {
1200       berrno be;
1201       Pmsg1(-1, _("3993 Bad autochanger command: %s\n"), changer);
1202       Pmsg2(-1, _("3993 result=\"%s\": ERR=%s\n"), results, be.strerror(status));
1203       goto bail_out;
1204    }
1205
1206    if (!open_the_device()) {
1207       goto bail_out;
1208    }
1209    /*
1210     * Start with sleep_time 0 then increment by 30 seconds if we get
1211     * a failure.
1212     */
1213    bmicrosleep(sleep_time, 0);
1214    if (!dev->rewind(dcr) || !dev->weof(1)) {
1215       Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
1216       dev->clrerror(-1);
1217       Pmsg0(-1, _("\nThe test failed, probably because you need to put\n"
1218                 "a longer sleep time in the mtx-script in the load) case.\n"
1219                 "Adding a 30 second sleep and trying again ...\n"));
1220       sleep_time += 30;
1221       goto try_again;
1222    } else {
1223       Pmsg1(0, _("Rewound %s\n"), dev->print_name());
1224    }
1225
1226    if (!dev->weof(1)) {
1227       Pmsg1(0, _("Bad status from weof. ERR=%s\n"), dev->bstrerror());
1228       goto bail_out;
1229    } else {
1230       Pmsg1(0, _("Wrote EOF to %s\n"), dev->print_name());
1231    }
1232
1233    if (sleep_time) {
1234       Pmsg1(-1, _("\nThe test worked this time. Please add:\n\n"
1235                 "   sleep %d\n\n"
1236                 "to your mtx-changer script in the load) case.\n\n"),
1237                 sleep_time);
1238    } else {
1239       Pmsg0(-1, _("\nThe test autochanger worked!!\n\n"));
1240    }
1241
1242    free_pool_memory(changer);
1243    free_pool_memory(results);
1244    return 1;
1245
1246
1247 bail_out:
1248    free_pool_memory(changer);
1249    free_pool_memory(results);
1250    Pmsg0(-1, _("You must correct this error or the Autochanger will not work.\n"));
1251    return -2;
1252 }
1253
1254 static void autochangercmd()
1255 {
1256    autochanger_test();
1257 }
1258
1259
1260 /*
1261  * This test assumes that the append test has been done,
1262  *   then it tests the fsf function.
1263  */
1264 static int fsf_test()
1265 {
1266    bool set_off = false;
1267
1268    Pmsg0(-1, _("\n\n=== Forward space files test ===\n\n"
1269                "This test is essential to Bacula.\n\n"
1270                "I'm going to write five files then test forward spacing\n\n"));
1271    argc = 1;
1272    rewindcmd();
1273    wrcmd();
1274    weofcmd();      /* end file 0 */
1275    wrcmd();
1276    wrcmd();
1277    weofcmd();      /* end file 1 */
1278    wrcmd();
1279    wrcmd();
1280    wrcmd();
1281    weofcmd();     /* end file 2 */
1282    wrcmd();
1283    wrcmd();
1284    weofcmd();     /* end file 3 */
1285    wrcmd();
1286    weofcmd();     /* end file 4 */
1287    if (dev_cap(dev, CAP_TWOEOF)) {
1288       weofcmd();
1289    }
1290
1291 test_again:
1292    rewindcmd();
1293    Pmsg0(0, _("Now forward spacing 1 file.\n"));
1294    if (!dev->fsf(1)) {
1295       Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1296       goto bail_out;
1297    }
1298    Pmsg2(-1, _("We should be in file 1. I am at file %d. %s\n"),
1299       dev->file, dev->file == 1 ? _("This is correct!") : _("This is NOT correct!!!!"));
1300
1301    if (dev->file != 1) {
1302       goto bail_out;
1303    }
1304
1305    Pmsg0(0, _("Now forward spacing 2 files.\n"));
1306    if (!dev->fsf(2)) {
1307       Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1308       goto bail_out;
1309    }
1310    Pmsg2(-1, _("We should be in file 3. I am at file %d. %s\n"),
1311       dev->file, dev->file == 3 ? _("This is correct!") : _("This is NOT correct!!!!"));
1312
1313    if (dev->file != 3) {
1314       goto bail_out;
1315    }
1316
1317    rewindcmd();
1318    Pmsg0(0, _("Now forward spacing 4 files.\n"));
1319    if (!dev->fsf(4)) {
1320       Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1321       goto bail_out;
1322    }
1323    Pmsg2(-1, _("We should be in file 4. I am at file %d. %s\n"),
1324       dev->file, dev->file == 4 ? _("This is correct!") : _("This is NOT correct!!!!"));
1325
1326    if (dev->file != 4) {
1327       goto bail_out;
1328    }
1329    if (set_off) {
1330       Pmsg0(-1, _("The test worked this time. Please add:\n\n"
1331                 "   Fast Forward Space File = no\n\n"
1332                 "to your Device resource for this drive.\n"));
1333    }
1334
1335    Pmsg0(-1, "\n");
1336    Pmsg0(0, _("Now forward spacing 1 more file.\n"));
1337    if (!dev->fsf(1)) {
1338       Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1339    }
1340    Pmsg2(-1, _("We should be in file 5. I am at file %d. %s\n"),
1341       dev->file, dev->file == 5 ? _("This is correct!") : _("This is NOT correct!!!!"));
1342    if (dev->file != 5) {
1343       goto bail_out;
1344    }
1345    Pmsg0(-1, _("\n=== End Forward space files test ===\n\n"));
1346    return 1;
1347
1348 bail_out:
1349    Pmsg0(-1, _("\nThe forward space file test failed.\n"));
1350    if (dev_cap(dev, CAP_FASTFSF)) {
1351       Pmsg0(-1, _("You have Fast Forward Space File enabled.\n"
1352               "I am turning it off then retrying the test.\n"));
1353       dev->capabilities &= ~CAP_FASTFSF;
1354       set_off = true;
1355       goto test_again;
1356    }
1357    Pmsg0(-1, _("You must correct this error or Bacula will not work.\n"
1358             "Some systems, e.g. OpenBSD, require you to set\n"
1359             "   Use MTIOCGET= no\n"
1360             "in your device resource. Use with caution.\n"));
1361    return -2;
1362 }
1363
1364
1365
1366
1367
1368 /*
1369  * This is a general test of Bacula's functions
1370  *   needed to read and write the tape.
1371  */
1372 static void testcmd()
1373 {
1374    int stat;
1375
1376    if (!write_read_test()) {
1377       return;
1378    }
1379    if (!position_test()) {
1380       return;
1381    }
1382
1383    stat = append_test();
1384    if (stat == 1) {                   /* OK get out */
1385       goto all_done;
1386    }
1387    if (stat == -1) {                  /* first test failed */
1388       if (dev_cap(dev, CAP_EOM) || dev_cap(dev, CAP_FASTFSF)) {
1389          Pmsg0(-1, _("\nAppend test failed. Attempting again.\n"
1390                    "Setting \"Hardware End of Medium = no\n"
1391                    "    and \"Fast Forward Space File = no\n"
1392                    "and retrying append test.\n\n"));
1393          dev->capabilities &= ~CAP_EOM; /* turn off eom */
1394          dev->capabilities &= ~CAP_FASTFSF; /* turn off fast fsf */
1395          stat = append_test();
1396          if (stat == 1) {
1397             Pmsg0(-1, _("\n\nIt looks like the test worked this time, please add:\n\n"
1398                      "    Hardware End of Medium = No\n\n"
1399                      "    Fast Forward Space File = No\n"
1400                      "to your Device resource in the Storage conf file.\n"));
1401             goto all_done;
1402          }
1403          if (stat == -1) {
1404             Pmsg0(-1, _("\n\nThat appears *NOT* to have corrected the problem.\n"));
1405             goto failed;
1406          }
1407          /* Wrong count after append */
1408          if (stat == -2) {
1409             Pmsg0(-1, _("\n\nIt looks like the append failed. Attempting again.\n"
1410                      "Setting \"BSF at EOM = yes\" and retrying append test.\n"));
1411             dev->capabilities |= CAP_BSFATEOM; /* backspace on eom */
1412             stat = append_test();
1413             if (stat == 1) {
1414                Pmsg0(-1, _("\n\nIt looks like the test worked this time, please add:\n\n"
1415                      "    Hardware End of Medium = No\n"
1416                      "    Fast Forward Space File = No\n"
1417                      "    BSF at EOM = yes\n\n"
1418                      "to your Device resource in the Storage conf file.\n"));
1419                goto all_done;
1420             }
1421          }
1422
1423       }
1424 failed:
1425       Pmsg0(-1, _("\nAppend test failed.\n\n"
1426             "\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"
1427             "Unable to correct the problem. You MUST fix this\n"
1428              "problem before Bacula can use your tape drive correctly\n"
1429             "\nPerhaps running Bacula in fixed block mode will work.\n"
1430             "Do so by setting:\n\n"
1431             "Minimum Block Size = nnn\n"
1432             "Maximum Block Size = nnn\n\n"
1433             "in your Storage daemon's Device definition.\n"
1434             "nnn must match your tape driver's block size, which\n"
1435             "can be determined by reading your tape manufacturers\n"
1436             "information, and the information on your kernel dirver.\n"
1437             "Fixed block sizes, however, are not normally an ideal solution.\n"
1438             "\n"
1439             "Some systems, e.g. OpenBSD, require you to set\n"
1440             "   Use MTIOCGET= no\n"
1441             "in your device resource. Use with caution.\n"));
1442        return;
1443    }
1444
1445 all_done:
1446    Pmsg0(-1, _("\nThe above Bacula scan should have output identical to what follows.\n"
1447         "Please double check it ...\n"
1448         "=== Sample correct output ===\n"
1449         "1 block of 64448 bytes in file 1\n"
1450         "End of File mark.\n"
1451         "2 blocks of 64448 bytes in file 2\n"
1452         "End of File mark.\n"
1453         "3 blocks of 64448 bytes in file 3\n"
1454         "End of File mark.\n"
1455         "1 block of 64448 bytes in file 4\n"
1456         "End of File mark.\n"
1457         "Total files=4, blocks=7, bytes = 451,136\n"
1458         "=== End sample correct output ===\n\n"
1459         "If the above scan output is not identical to the\n"
1460         "sample output, you MUST correct the problem\n"
1461         "or Bacula will not be able to write multiple Jobs to \n"
1462         "the tape.\n\n"));
1463
1464    if (stat == 1) {
1465       re_read_block_test();
1466    }
1467
1468    fsf_test();                        /* do fast forward space file test */
1469
1470    autochanger_test();                /* do autochanger test */
1471
1472 }
1473
1474 /* Forward space a file */
1475 static void fsfcmd()
1476 {
1477    int num = 1;
1478    if (argc > 1) {
1479       num = atoi(argk[1]);
1480    }
1481    if (num <= 0) {
1482       num = 1;
1483    }
1484    if (!dev->fsf(num)) {
1485       Pmsg1(0, _("Bad status from fsf. ERR=%s\n"), dev->bstrerror());
1486       return;
1487    }
1488    if (num == 1) {
1489       Pmsg0(0, _("Forward spaced 1 file.\n"));
1490    }
1491    else {
1492       Pmsg1(0, _("Forward spaced %d files.\n"), num);
1493    }
1494 }
1495
1496 /* Forward space a record */
1497 static void fsrcmd()
1498 {
1499    int num = 1;
1500    if (argc > 1) {
1501       num = atoi(argk[1]);
1502    }
1503    if (num <= 0) {
1504       num = 1;
1505    }
1506    if (!dev->fsr(num)) {
1507       Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1508       return;
1509    }
1510    if (num == 1) {
1511       Pmsg0(0, _("Forward spaced 1 record.\n"));
1512    }
1513    else {
1514       Pmsg1(0, _("Forward spaced %d records.\n"), num);
1515    }
1516 }
1517
1518 /*
1519  * Read a Bacula block from the tape
1520  */
1521 static void rbcmd()
1522 {
1523    dev->open(dcr, OPEN_READ_ONLY);
1524    read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK);
1525 }
1526
1527 /*
1528  * Write a Bacula block to the tape
1529  */
1530 static void wrcmd()
1531 {
1532    DEV_BLOCK *block = dcr->block;
1533    DEV_RECORD *rec = dcr->rec;
1534    int i;
1535
1536    open_the_device();
1537    sm_check(__FILE__, __LINE__, false);
1538    empty_block(block);
1539    if (verbose > 1) {
1540       dump_block(block, "test");
1541    }
1542
1543    i = block->buf_len - 100;
1544    ASSERT (i > 0);
1545    rec->data = check_pool_memory_size(rec->data, i);
1546    memset(rec->data, i & 0xFF, i);
1547    rec->data_len = i;
1548    sm_check(__FILE__, __LINE__, false);
1549    if (!write_record_to_block(block, rec)) {
1550       Pmsg0(0, _("Error writing record to block.\n"));
1551       goto bail_out;
1552    }
1553    if (!write_block_to_dev(dcr)) {
1554       Pmsg0(0, _("Error writing block to device.\n"));
1555       goto bail_out;
1556    } else {
1557       Pmsg1(0, _("Wrote one record of %d bytes.\n"), i);
1558    }
1559    Pmsg0(0, _("Wrote block to device.\n"));
1560
1561 bail_out:
1562    sm_check(__FILE__, __LINE__, false);
1563    sm_check(__FILE__, __LINE__, false);
1564 }
1565
1566 /*
1567  * Read a record from the tape
1568  */
1569 static void rrcmd()
1570 {
1571    char *buf;
1572    int stat, len;
1573
1574    if (!get_cmd(_("Enter length to read: "))) {
1575       return;
1576    }
1577    len = atoi(cmd);
1578    if (len < 0 || len > 1000000) {
1579       Pmsg0(0, _("Bad length entered, using default of 1024 bytes.\n"));
1580       len = 1024;
1581    }
1582    buf = (char *)malloc(len);
1583    stat = read(dev->fd, buf, len);
1584    if (stat > 0 && stat <= len) {
1585       errno = 0;
1586    }
1587    berrno be;
1588    Pmsg3(0, _("Read of %d bytes gives stat=%d. ERR=%s\n"),
1589       len, stat, be.strerror());
1590    free(buf);
1591 }
1592
1593
1594 /*
1595  * Scan tape by reading block by block. Report what is
1596  * on the tape.  Note, this command does raw reads, and as such
1597  * will not work with fixed block size devices.
1598  */
1599 static void scancmd()
1600 {
1601    int stat;
1602    int blocks, tot_blocks, tot_files;
1603    int block_size;
1604    uint64_t bytes;
1605    char ec1[50];
1606
1607
1608    blocks = block_size = tot_blocks = 0;
1609    bytes = 0;
1610    if (dev->state & ST_EOT) {
1611       Pmsg0(0, _("End of tape\n"));
1612       return;
1613    }
1614    dev->update_pos(dcr);
1615    tot_files = dev->file;
1616    Pmsg1(0, _("Starting scan at file %u\n"), dev->file);
1617    for (;;) {
1618       if ((stat = read(dev->fd, buf, sizeof(buf))) < 0) {
1619          berrno be;
1620          dev->clrerror(-1);
1621          Mmsg2(dev->errmsg, _("read error on %s. ERR=%s.\n"),
1622             dev->dev_name, be.strerror());
1623          Pmsg2(0, _("Bad status from read %d. ERR=%s\n"), stat, dev->bstrerror());
1624          if (blocks > 0) {
1625             if (blocks==1) {
1626                printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1627             }
1628             else {
1629                printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1630             }
1631          }
1632          return;
1633       }
1634       Dmsg1(200, "read status = %d\n", stat);
1635 /*    sleep(1); */
1636       if (stat != block_size) {
1637          dev->update_pos(dcr);
1638          if (blocks > 0) {
1639             if (blocks==1) {
1640                printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1641             }
1642             else {
1643                printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1644             }
1645             blocks = 0;
1646          }
1647          block_size = stat;
1648       }
1649       if (stat == 0) {                /* EOF */
1650          dev->update_pos(dcr);
1651          printf(_("End of File mark.\n"));
1652          /* Two reads of zero means end of tape */
1653          if (dev->state & ST_EOF)
1654             dev->state |= ST_EOT;
1655          else {
1656             dev->state |= ST_EOF;
1657             dev->file++;
1658          }
1659          if (dev->state & ST_EOT) {
1660             printf(_("End of tape\n"));
1661             break;
1662          }
1663       } else {                        /* Got data */
1664          dev->state &= ~ST_EOF;
1665          blocks++;
1666          tot_blocks++;
1667          bytes += stat;
1668       }
1669    }
1670    dev->update_pos(dcr);
1671    tot_files = dev->file - tot_files;
1672    printf(_("Total files=%d, blocks=%d, bytes = %s\n"), tot_files, tot_blocks,
1673       edit_uint64_with_commas(bytes, ec1));
1674 }
1675
1676
1677 /*
1678  * Scan tape by reading Bacula block by block. Report what is
1679  * on the tape.  This function reads Bacula blocks, so if your
1680  * Device resource is correctly defined, it should work with
1681  * either variable or fixed block sizes.
1682  */
1683 static void scan_blocks()
1684 {
1685    int blocks, tot_blocks, tot_files;
1686    uint32_t block_size;
1687    uint64_t bytes;
1688    DEV_BLOCK *block = dcr->block;
1689    char ec1[50];
1690    char buf1[100], buf2[100];
1691
1692    blocks = block_size = tot_blocks = 0;
1693    bytes = 0;
1694
1695    empty_block(block);
1696    dev->update_pos(dcr);
1697    tot_files = dev->file;
1698    for (;;) {
1699       if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
1700          Dmsg1(100, "!read_block(): ERR=%s\n", dev->bstrerror());
1701          if (dev->state & ST_EOT) {
1702             if (blocks > 0) {
1703                if (blocks==1) {
1704                   printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1705                }
1706                else {
1707                   printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1708                }
1709                blocks = 0;
1710             }
1711             goto bail_out;
1712          }
1713          if (dev->state & ST_EOF) {
1714             if (blocks > 0) {
1715                if (blocks==1) {
1716                   printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1717                }
1718                else {
1719                   printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1720                }
1721                blocks = 0;
1722             }
1723             printf(_("End of File mark.\n"));
1724             continue;
1725          }
1726          if (dev->state & ST_SHORT) {
1727             if (blocks > 0) {
1728                if (blocks==1) {
1729                   printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1730                }
1731                else {
1732                   printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1733                }
1734                blocks = 0;
1735             }
1736             printf(_("Short block read.\n"));
1737             continue;
1738          }
1739          printf(_("Error reading block. ERR=%s\n"), dev->bstrerror());
1740          goto bail_out;
1741       }
1742       if (block->block_len != block_size) {
1743          if (blocks > 0) {
1744             if (blocks==1) {
1745                printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1746             }
1747             else {
1748                printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1749             }
1750             blocks = 0;
1751          }
1752          block_size = block->block_len;
1753       }
1754       blocks++;
1755       tot_blocks++;
1756       bytes += block->block_len;
1757       Dmsg6(100, "Blk_blk=%u dev_blk=%u blen=%u bVer=%d SessId=%u SessTim=%u\n",
1758          block->BlockNumber, dev->block_num, block->block_len, block->BlockVer,
1759          block->VolSessionId, block->VolSessionTime);
1760       if (verbose == 1) {
1761          DEV_RECORD *rec = new_record();
1762          read_record_from_block(block, rec);
1763          Pmsg8(-1, _("Blk_block: %u dev_blk=%u blen=%u First rec FI=%s SessId=%u SessTim=%u Strm=%s rlen=%d\n"),
1764               block->BlockNumber, dev->block_num, block->block_len,
1765               FI_to_ascii(buf1, rec->FileIndex), rec->VolSessionId, rec->VolSessionTime,
1766               stream_to_ascii(buf2, rec->Stream, rec->FileIndex), rec->data_len);
1767          rec->remainder = 0;
1768          free_record(rec);
1769       } else if (verbose > 1) {
1770          dump_block(block, "");
1771       }
1772
1773    }
1774 bail_out:
1775    tot_files = dev->file - tot_files;
1776    printf(_("Total files=%d, blocks=%d, bytes = %s\n"), tot_files, tot_blocks,
1777       edit_uint64_with_commas(bytes, ec1));
1778 }
1779
1780
1781 static void statcmd()
1782 {
1783    int debug = debug_level;
1784    debug_level = 30;
1785    Pmsg2(0, _("Device status: %u. ERR=%s\n"), status_dev(dev), dev->bstrerror());
1786 #ifdef xxxx
1787    dump_volume_label(dev);
1788 #endif
1789    debug_level = debug;
1790 }
1791
1792
1793 /*
1794  * First we label the tape, then we fill
1795  *  it with data get a new tape and write a few blocks.
1796  */
1797 static void fillcmd()
1798 {
1799    DEV_RECORD rec;
1800    DEV_BLOCK  *block = dcr->block;
1801    char ec1[50];
1802    char buf1[100], buf2[100];
1803    int fd;
1804    uint32_t i;
1805    uint32_t min_block_size;
1806    struct tm tm;
1807
1808    ok = true;
1809    stop = 0;
1810    vol_num = 0;
1811    last_file = 0;
1812    last_block_num = 0;
1813    BlockNumber = 0;
1814
1815    Pmsg0(-1, _("\n"
1816 "This command simulates Bacula writing to a tape.\n"
1817 "It requires either one or two blank tapes, which it\n"
1818 "will label and write.\n\n"
1819 "If you have an autochanger configured, it will use\n"
1820 "the tapes that are in slots 1 and 2, otherwise, you will\n"
1821 "be prompted to insert the tapes when necessary.\n\n"
1822 "It will print a status approximately\n"
1823 "every 322 MB, and write an EOF every 3.2 GB.  If you have\n"
1824 "selected the simple test option, after writing the first tape\n"
1825 "it will rewind it and re-read the last block written.\n\n"
1826 "If you have selected the multiple tape test, when the first tape\n"
1827 "fills, it will ask for a second, and after writing a few more \n"
1828 "blocks, it will stop.  Then it will begin re-reading the\n"
1829 "two tapes.\n\n"
1830 "This may take a long time -- hours! ...\n\n"));
1831
1832    get_cmd(_("Do you want to run the simplified test (s) with one tape\n"
1833            "or the complete multiple tape (m) test: (s/m) "));
1834    if (cmd[0] == 's') {
1835       Pmsg0(-1, _("Simple test (single tape) selected.\n"));
1836       simple = true;
1837    } else if (cmd[0] == 'm') {
1838       Pmsg0(-1, _("Multiple tape test selected.\n"));
1839       simple = false;
1840    } else {
1841       Pmsg0(000, _("Command aborted.\n"));
1842       return;
1843    }
1844
1845    Dmsg1(20, "Begin append device=%s\n", dev->print_name());
1846    Dmsg1(20, "MaxVolSize=%s\n", edit_uint64(dev->max_volume_size, ec1));
1847
1848    /* Use fixed block size to simplify read back */
1849    min_block_size = dev->min_block_size;
1850    dev->min_block_size = dev->max_block_size;
1851    set_volume_name("TestVolume1", 1);
1852    dir_ask_sysop_to_create_appendable_volume(dcr);
1853    dev->set_append();                 /* force volume to be relabeled */
1854
1855    /*
1856     * Acquire output device for writing.  Note, after acquiring a
1857     *   device, we MUST release it, which is done at the end of this
1858     *   subroutine.
1859     */
1860    Dmsg0(100, "just before acquire_device\n");
1861    if (!acquire_device_for_append(dcr)) {
1862       set_jcr_job_status(jcr, JS_ErrorTerminated);
1863       return;
1864    }
1865    block = jcr->dcr->block;
1866
1867    Dmsg0(100, "Just after acquire_device_for_append\n");
1868    /*
1869     * Write Begin Session Record
1870     */
1871    if (!write_session_label(dcr, SOS_LABEL)) {
1872       set_jcr_job_status(jcr, JS_ErrorTerminated);
1873       Jmsg1(jcr, M_FATAL, 0, _("Write session label failed. ERR=%s\n"),
1874          dev->bstrerror());
1875       ok = false;
1876    }
1877    Pmsg0(-1, _("Wrote Start of Session label.\n"));
1878
1879    memset(&rec, 0, sizeof(rec));
1880    rec.data = get_memory(100000);     /* max record size */
1881
1882 #define REC_SIZE 32768
1883    rec.data_len = REC_SIZE;
1884
1885    /*
1886     * Put some random data in the record
1887     */
1888    fd = open("/dev/urandom", O_RDONLY);
1889    if (fd != -1) {
1890       read(fd, rec.data, rec.data_len);
1891       close(fd);
1892    } else {
1893       uint32_t *p = (uint32_t *)rec.data;
1894       srandom(time(NULL));
1895       for (i=0; i<rec.data_len/sizeof(uint32_t); i++) {
1896          p[i] = random();
1897       }
1898    }
1899
1900    /*
1901     * Generate data as if from File daemon, write to device
1902     */
1903    jcr->dcr->VolFirstIndex = 0;
1904    time(&jcr->run_time);              /* start counting time for rates */
1905    (void)localtime_r(&jcr->run_time, &tm);
1906    strftime(buf1, sizeof(buf1), "%H:%M:%S", &tm);
1907    if (simple) {
1908       Pmsg1(-1, _("%s Begin writing Bacula records to tape ...\n"), buf1);
1909    } else {
1910       Pmsg1(-1, _("%s Begin writing Bacula records to first tape ...\n"), buf1);
1911    }
1912    for (file_index = 0; ok && !job_canceled(jcr); ) {
1913       rec.VolSessionId = jcr->VolSessionId;
1914       rec.VolSessionTime = jcr->VolSessionTime;
1915       rec.FileIndex = ++file_index;
1916       rec.Stream = STREAM_FILE_DATA;
1917
1918       /* Mix up the data just a bit */
1919       uint32_t *lp = (uint32_t *)rec.data;
1920       lp[0] += lp[13];
1921       for (i=1; i < (rec.data_len-sizeof(uint32_t))/sizeof(uint32_t)-1; i++) {
1922          lp[i] += lp[i-1];
1923       }
1924
1925       Dmsg4(250, "before write_rec FI=%d SessId=%d Strm=%s len=%d\n",
1926          rec.FileIndex, rec.VolSessionId,
1927          stream_to_ascii(buf1, rec.Stream, rec.FileIndex),
1928          rec.data_len);
1929
1930       while (!write_record_to_block(block, &rec)) {
1931          /*
1932           * When we get here we have just filled a block
1933           */
1934          Dmsg2(150, "!write_record_to_block data_len=%d rem=%d\n", rec.data_len,
1935                     rec.remainder);
1936
1937          /* Write block to tape */
1938          if (!flush_block(block, 1)) {
1939             break;
1940          }
1941
1942          /* Every 5000 blocks (approx 322MB) report where we are.
1943           */
1944          if ((block->BlockNumber % 5000) == 0) {
1945             now = time(NULL);
1946             now -= jcr->run_time;
1947             if (now <= 0) {
1948                now = 1;          /* prevent divide error */
1949             }
1950             kbs = (double)dev->VolCatInfo.VolCatBytes / (1000.0 * (double)now);
1951             Pmsg4(-1, _("Wrote blk_block=%u, dev_blk_num=%u VolBytes=%s rate=%.1f KB/s\n"),
1952                block->BlockNumber, dev->block_num,
1953                edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, ec1), (float)kbs);
1954          }
1955          /* Every 32000 blocks (approx 2GB) write an EOF.
1956           */
1957          if ((block->BlockNumber % 32000) == 0) {
1958             now = time(NULL);
1959             (void)localtime_r(&now, &tm);
1960             strftime(buf1, sizeof(buf1), "%H:%M:%S", &tm);
1961             Pmsg1(-1, _("%s Flush block, write EOF\n"), buf1);
1962             flush_block(block, 0);
1963             dev->weof(1);
1964          }
1965
1966          /* Get out after writing 10 blocks to the second tape */
1967          if (++BlockNumber > 10 && stop != 0) {      /* get out */
1968             break;
1969          }
1970       }
1971       if (!ok) {
1972          Pmsg0(000, _("Not OK\n"));
1973          break;
1974       }
1975       jcr->JobBytes += rec.data_len;   /* increment bytes this job */
1976       Dmsg4(190, "write_record FI=%s SessId=%d Strm=%s len=%d\n",
1977          FI_to_ascii(buf1, rec.FileIndex), rec.VolSessionId,
1978          stream_to_ascii(buf2, rec.Stream, rec.FileIndex), rec.data_len);
1979
1980       /* Get out after writing 10 blocks to the second tape */
1981       if (BlockNumber > 10 && stop != 0) {      /* get out */
1982          char ed1[50];
1983          Pmsg1(-1, "Done writing %s records ...\n",
1984              edit_uint64_with_commas(write_count, ed1));
1985          break;
1986       }
1987    }
1988    if (vol_num > 1) {
1989       Dmsg0(100, "Write_end_session_label()\n");
1990       /* Create Job status for end of session label */
1991       if (!job_canceled(jcr) && ok) {
1992          set_jcr_job_status(jcr, JS_Terminated);
1993       } else if (!ok) {
1994          set_jcr_job_status(jcr, JS_ErrorTerminated);
1995       }
1996       if (!write_session_label(dcr, EOS_LABEL)) {
1997          Pmsg1(000, _("Error writting end session label. ERR=%s\n"), dev->bstrerror());
1998          ok = false;
1999       }
2000       /* Write out final block of this session */
2001       if (!write_block_to_device(dcr)) {
2002          Pmsg0(-1, _("Set ok=false after write_block_to_device.\n"));
2003          ok = false;
2004       }
2005       Pmsg0(-1, _("Wrote End of Session label.\n"));
2006
2007       /* Save last block info for second tape */
2008       last_block_num2 = last_block_num;
2009       last_file2 = last_file;
2010       if (last_block2) {
2011          free_block(last_block2);
2012       }
2013       last_block2 = dup_block(last_block);
2014    }
2015
2016    sprintf(buf, "%s/btape.state", working_directory);
2017    fd = open(buf, O_CREAT|O_TRUNC|O_WRONLY, 0640);
2018    if (fd >= 0) {
2019       write(fd, &btape_state_level, sizeof(btape_state_level));
2020       write(fd, &simple, sizeof(simple));
2021       write(fd, &last_block_num1, sizeof(last_block_num1));
2022       write(fd, &last_block_num2, sizeof(last_block_num2));
2023       write(fd, &last_file1, sizeof(last_file1));
2024       write(fd, &last_file2, sizeof(last_file2));
2025       write(fd, last_block1->buf, last_block1->buf_len);
2026       write(fd, last_block2->buf, last_block2->buf_len);
2027       write(fd, first_block->buf, first_block->buf_len);
2028       close(fd);
2029       Pmsg2(-1, _("Wrote state file last_block_num1=%d last_block_num2=%d\n"),
2030          last_block_num1, last_block_num2);
2031    } else {
2032       berrno be;
2033       Pmsg2(-1, _("Could not create state file: %s ERR=%s\n"), buf,
2034                  be.strerror());
2035    }
2036
2037    now = time(NULL);
2038    (void)localtime_r(&now, &tm);
2039    strftime(buf1, sizeof(buf1), "%H:%M:%S", &tm);
2040    if (simple) {
2041       Pmsg3(-1, _("\n\n%s Done filling tape at %d:%d. Now beginning re-read of tape ...\n"),
2042          buf1, jcr->dcr->dev->file, jcr->dcr->dev->block_num);
2043    }
2044    else {
2045       Pmsg3(-1, _("\n\n%s Done filling tapes at %d:%d. Now beginning re-read of first tape ...\n"),
2046          buf1, jcr->dcr->dev->file, jcr->dcr->dev->block_num);
2047    }
2048
2049    jcr->dcr->block = block;
2050    do_unfill();
2051
2052    dev->min_block_size = min_block_size;
2053    free_memory(rec.data);
2054 }
2055
2056 /*
2057  * Read two tapes written by the "fill" command and ensure
2058  *  that the data is valid.  If stop==1 we simulate full read back
2059  *  of two tapes.  If stop==-1 we simply read the last block and
2060  *  verify that it is correct.
2061  */
2062 static void unfillcmd()
2063 {
2064    int fd;
2065
2066    last_block1 = new_block(dev);
2067    last_block2 = new_block(dev);
2068    first_block = new_block(dev);
2069    sprintf(buf, "%s/btape.state", working_directory);
2070    fd = open(buf, O_RDONLY);
2071    if (fd >= 0) {
2072       uint32_t state_level;
2073       read(fd, &state_level, sizeof(btape_state_level));
2074       read(fd, &simple, sizeof(simple));
2075       read(fd, &last_block_num1, sizeof(last_block_num1));
2076       read(fd, &last_block_num2, sizeof(last_block_num2));
2077       read(fd, &last_file1, sizeof(last_file1));
2078       read(fd, &last_file2, sizeof(last_file2));
2079       read(fd, last_block1->buf, last_block1->buf_len);
2080       read(fd, last_block2->buf, last_block2->buf_len);
2081       read(fd, first_block->buf, first_block->buf_len);
2082       close(fd);
2083       if (state_level != btape_state_level) {
2084           Pmsg0(-1, _("\nThe state file level has changed. You must redo\n"
2085                   "the fill command.\n"));
2086           return;
2087        }
2088    } else {
2089       berrno be;
2090       Pmsg2(-1, _("\nCould not find the state file: %s ERR=%s\n"
2091              "You must redo the fill command.\n"), buf, be.strerror());
2092       return;
2093    }
2094    do_unfill();
2095    this_block = NULL;
2096 }
2097
2098 static void do_unfill()
2099 {
2100    DEV_BLOCK *block = dcr->block;
2101    bool autochanger;
2102
2103    dumped = 0;
2104    VolBytes = 0;
2105    LastBlock = 0;
2106
2107    Dmsg0(20, "Enter do_unfill\n");
2108    dev->capabilities |= CAP_ANONVOLS; /* allow reading any volume */
2109    dev->capabilities &= ~CAP_LABEL;   /* don't label anything here */
2110
2111    end_of_tape = 0;
2112
2113    time(&jcr->run_time);              /* start counting time for rates */
2114    stop = 0;
2115    file_index = 0;
2116    if (last_block) {
2117       free_block(last_block);
2118       last_block = NULL;
2119    }
2120    last_block_num = last_block_num1;
2121    last_file = last_file1;
2122    last_block = last_block1;
2123
2124    free_restore_volume_list(jcr);
2125    jcr->bsr = NULL;
2126    bstrncpy(dcr->VolumeName, "TestVolume1|TestVolume2", sizeof(dcr->VolumeName));
2127    create_restore_volume_list(jcr);
2128    if (jcr->VolList != NULL) {
2129       jcr->VolList->Slot = 1;
2130       if (jcr->VolList->next != NULL) {
2131          jcr->VolList->next->Slot = 2;
2132       }
2133    }
2134
2135    set_volume_name("TestVolume1", 1);
2136
2137    if (!simple) {
2138       /* Multiple Volume tape */
2139       /* Close device so user can use autochanger if desired */
2140       if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2141          dev->offline();
2142       }
2143       autochanger = autoload_device(dcr, 1, NULL);
2144       if (!autochanger) {
2145          dev->close();
2146          get_cmd(_("Mount first tape. Press enter when ready: "));
2147       }
2148    }
2149
2150    dev->close();
2151    dev->num_writers = 0;
2152    if (!acquire_device_for_read(dcr)) {
2153       Pmsg1(-1, "%s", dev->errmsg);
2154       goto bail_out;
2155    }
2156    /*
2157     * We now have the first tape mounted.
2158     * Note, re-reading last block may have caused us to
2159     *   loose track of where we are (block number unknown).
2160     */
2161    Pmsg0(-1, _("Rewinding.\n"));
2162    if (!dev->rewind(dcr)) {                /* get to a known place on tape */
2163       goto bail_out;
2164    }
2165    /* Read the first 10000 records */
2166    Pmsg2(-1, _("Reading the first 10000 records from %u:%u.\n"),
2167       dev->file, dev->block_num);
2168    quickie_count = 0;
2169    read_records(dcr, quickie_cb, my_mount_next_read_volume);
2170    Pmsg4(-1, _("Reposition from %u:%u to %u:%u\n"), dev->file, dev->block_num,
2171          last_file, last_block_num);
2172    if (!dev->reposition(dcr, last_file, last_block_num)) {
2173       Pmsg1(-1, _("Reposition error. ERR=%s\n"), dev->bstrerror());
2174       goto bail_out;
2175    }
2176    Pmsg1(-1, _("Reading block %u.\n"), last_block_num);
2177    if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2178       Pmsg1(-1, _("Error reading block: ERR=%s\n"), dev->bstrerror());
2179       goto bail_out;
2180    }
2181    if (compare_blocks(last_block, block)) {
2182       if (simple) {
2183          Pmsg0(-1, _("\nThe last block on the tape matches. Test succeeded.\n\n"));
2184       } else {
2185          Pmsg0(-1, _("\nThe last block of the first tape matches.\n\n"));
2186       }
2187    }
2188    if (simple) {
2189       goto bail_out;
2190    }
2191
2192    /* restore info for last block on second Volume */
2193    last_block_num = last_block_num2;
2194    last_file = last_file2;
2195    last_block = last_block2;
2196
2197    /* Multiple Volume tape */
2198    /* Close device so user can use autochanger if desired */
2199    if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2200       dev->offline();
2201    }
2202
2203    set_volume_name("TestVolume2", 2);
2204
2205    autochanger = autoload_device(dcr, 1, NULL);
2206    if (!autochanger) {
2207       dev->close();
2208       get_cmd(_("Mount second tape. Press enter when ready: "));
2209    }
2210
2211    dev->clear_read();
2212    if (!acquire_device_for_read(dcr)) {
2213       Pmsg1(-1, "%s", dev->errmsg);
2214       goto bail_out;
2215    }
2216
2217    /* Space to "first" block which is last block not written
2218     * on the previous tape.
2219     */
2220    Pmsg2(-1, _("Reposition from %u:%u to 0:1\n"), dev->file, dev->block_num);
2221    if (!dev->reposition(dcr, 0, 1)) {
2222       Pmsg1(-1, _("Reposition error. ERR=%s\n"), dev->bstrerror());
2223       goto bail_out;
2224    }
2225    Pmsg1(-1, _("Reading block %d.\n"), dev->block_num);
2226    if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2227       Pmsg1(-1, _("Error reading block: ERR=%s\n"), dev->bstrerror());
2228       goto bail_out;
2229    }
2230    if (compare_blocks(first_block, block)) {
2231       Pmsg0(-1, _("\nThe first block on the second tape matches.\n\n"));
2232    }
2233
2234    /* Now find and compare the last block */
2235    Pmsg4(-1, _("Reposition from %u:%u to %u:%u\n"), dev->file, dev->block_num,
2236          last_file, last_block_num);
2237    if (!dev->reposition(dcr, last_file, last_block_num)) {
2238       Pmsg1(-1, _("Reposition error. ERR=%s\n"), dev->bstrerror());
2239       goto bail_out;
2240    }
2241    Pmsg1(-1, _("Reading block %d.\n"), dev->block_num);
2242    if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2243       Pmsg1(-1, _("Error reading block: ERR=%s\n"), dev->bstrerror());
2244       goto bail_out;
2245    }
2246    if (compare_blocks(last_block, block)) {
2247       Pmsg0(-1, _("\nThe last block on the second tape matches. Test succeeded.\n\n"));
2248    }
2249
2250 bail_out:
2251    free_block(last_block1);
2252    free_block(last_block2);
2253    free_block(first_block);
2254 }
2255
2256 /* Read 10000 records then stop */
2257 static bool quickie_cb(DCR *dcr, DEV_RECORD *rec)
2258 {
2259    DEVICE *dev = dcr->dev;
2260    quickie_count++;
2261    if (quickie_count == 10000) {
2262       Pmsg2(-1, _("10000 records read now at %d:%d\n"), dev->file, dev->block_num);
2263    }
2264    return quickie_count < 10000;
2265 }
2266
2267 static bool compare_blocks(DEV_BLOCK *last_block, DEV_BLOCK *block)
2268 {
2269    char *p, *q;
2270    uint32_t CheckSum, block_len;
2271    ser_declare;
2272
2273    p = last_block->buf;
2274    q = block->buf;
2275    unser_begin(q, BLKHDR2_LENGTH);
2276    unser_uint32(CheckSum);
2277    unser_uint32(block_len);
2278    while (q < (block->buf+block_len)) {
2279       if (*p == *q) {
2280          p++;
2281          q++;
2282          continue;
2283       }
2284       Pmsg0(-1, "\n");
2285       dump_block(last_block, _("Last block written"));
2286       Pmsg0(-1, "\n");
2287       dump_block(block, _("Block read back"));
2288       Pmsg1(-1, _("\n\nThe blocks differ at byte %u\n"), p - last_block->buf);
2289       Pmsg0(-1, _("\n\n!!!! The last block written and the block\n"
2290                 "that was read back differ. The test FAILED !!!!\n"
2291                 "This must be corrected before you use Bacula\n"
2292                 "to write multi-tape Volumes.!!!!\n"));
2293       return false;
2294    }
2295    if (verbose) {
2296       dump_block(last_block, _("Last block written"));
2297       dump_block(block, _("Block read back"));
2298    }
2299    return true;
2300 }
2301
2302
2303
2304
2305
2306 /*
2307  * Write current block to tape regardless of whether or
2308  *   not it is full. If the tape fills, attempt to
2309  *   acquire another tape.
2310  */
2311 static int flush_block(DEV_BLOCK *block, int dump)
2312 {
2313    char ec1[50];
2314    DEV_BLOCK *tblock;
2315    uint32_t this_file, this_block_num;
2316
2317    lock_device(dev);
2318    if (!this_block) {
2319       this_block = new_block(dev);
2320    }
2321    if (!last_block) {
2322       last_block = new_block(dev);
2323    }
2324    /* Copy block */
2325    this_file = dev->file;
2326    this_block_num = dev->block_num;
2327    if (!write_block_to_dev(dcr)) {
2328       Pmsg3(000, _("Last block at: %u:%u this_dev_block_num=%d\n"),
2329                   last_file, last_block_num, this_block_num);
2330       if (vol_num == 1) {
2331          /*
2332           * This is 1st tape, so save first tape info separate
2333           *  from second tape info
2334           */
2335          last_block_num1 = last_block_num;
2336          last_file1 = last_file;
2337          last_block1 = dup_block(last_block);
2338          last_block2 = dup_block(last_block);
2339          first_block = dup_block(block); /* first block second tape */
2340       }
2341       if (verbose) {
2342          Pmsg3(000, _("Block not written: FileIndex=%u blk_block=%u Size=%u\n"),
2343             (unsigned)file_index, block->BlockNumber, block->block_len);
2344          dump_block(last_block, _("Last block written"));
2345          Pmsg0(-1, "\n");
2346          dump_block(block, _("Block not written"));
2347       }
2348       if (stop == 0) {
2349          eot_block = block->BlockNumber;
2350          eot_block_len = block->block_len;
2351          eot_FileIndex = file_index;
2352          stop = 1;
2353       }
2354       now = time(NULL);
2355       now -= jcr->run_time;
2356       if (now <= 0) {
2357          now = 1;                     /* don't divide by zero */
2358       }
2359       kbs = (double)dev->VolCatInfo.VolCatBytes / (1000 * now);
2360       vol_size = dev->VolCatInfo.VolCatBytes;
2361       Pmsg4(000, _("End of tape %d:%d. VolumeCapacity=%s. Write rate = %.1f KB/s\n"),
2362          dev->file, dev->block_num,
2363          edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, ec1), kbs);
2364
2365       if (simple) {
2366          stop = -1;                   /* stop, but do simplified test */
2367       } else {
2368          /* Full test in progress */
2369          if (!fixup_device_block_write_error(jcr->dcr)) {
2370             Pmsg1(000, _("Cannot fixup device error. %s\n"), dev->bstrerror());
2371             ok = false;
2372             unlock_device(dev);
2373             return 0;
2374          }
2375          BlockNumber = 0;             /* start counting for second tape */
2376       }
2377       unlock_device(dev);
2378       return 1;                       /* end of tape reached */
2379    }
2380
2381    /* Save contents after write so that the header is serialized */
2382    memcpy(this_block->buf, block->buf, this_block->buf_len);
2383
2384    /*
2385     * Note, we always read/write to block, but we toggle
2386     *  copying it to one or another of two allocated blocks.
2387     * Switch blocks so that the block just successfully written is
2388     *  always in last_block.
2389     */
2390    tblock = last_block;
2391    last_block = this_block;
2392    this_block = tblock;
2393    last_file = this_file;
2394    last_block_num = this_block_num;
2395
2396    unlock_device(dev);
2397    return 1;
2398 }
2399
2400
2401 /*
2402  * First we label the tape, then we fill
2403  *  it with data get a new tape and write a few blocks.
2404  */
2405 static void qfillcmd()
2406 {
2407    DEV_BLOCK *block = dcr->block;
2408    DEV_RECORD *rec = dcr->rec;
2409    int i, count;
2410
2411    Pmsg0(0, _("Test writing blocks of 64512 bytes to tape.\n"));
2412
2413    get_cmd(_("How many blocks do you want to write? (1000): "));
2414
2415    count = atoi(cmd);
2416    if (count <= 0) {
2417       count = 1000;
2418    }
2419
2420    sm_check(__FILE__, __LINE__, false);
2421
2422    i = block->buf_len - 100;
2423    ASSERT (i > 0);
2424    rec->data = check_pool_memory_size(rec->data, i);
2425    memset(rec->data, i & 0xFF, i);
2426    rec->data_len = i;
2427    rewindcmd();
2428    Pmsg1(0, _("Begin writing %d Bacula blocks to tape ...\n"), count);
2429    for (i=0; i < count; i++) {
2430       if (i % 100 == 0) {
2431          printf("+");
2432          fflush(stdout);
2433       }
2434       if (!write_record_to_block(block, rec)) {
2435          Pmsg0(0, _("Error writing record to block.\n"));
2436          goto bail_out;
2437       }
2438       if (!write_block_to_dev(dcr)) {
2439          Pmsg0(0, _("Error writing block to device.\n"));
2440          goto bail_out;
2441       }
2442    }
2443    printf("\n");
2444    weofcmd();
2445    if (dev_cap(dev, CAP_TWOEOF)) {
2446       weofcmd();
2447    }
2448    rewindcmd();
2449    scan_blocks();
2450
2451 bail_out:
2452    sm_check(__FILE__, __LINE__, false);
2453 }
2454
2455 /*
2456  * Fill a tape using raw write() command
2457  */
2458 static void rawfill_cmd()
2459 {
2460    DEV_BLOCK *block = dcr->block;
2461    int stat;
2462    int fd;
2463    uint32_t block_num = 0;
2464    uint32_t *p;
2465    int my_errno;
2466    uint32_t i;
2467
2468    fd = open("/dev/urandom", O_RDONLY);
2469    if (fd) {
2470       read(fd, block->buf, block->buf_len);
2471       close(fd);
2472    } else {
2473       uint32_t *p = (uint32_t *)block->buf;
2474       srandom(time(NULL));
2475       for (i=0; i<block->buf_len/sizeof(uint32_t); i++) {
2476          p[i] = random();
2477       }
2478    }
2479    p = (uint32_t *)block->buf;
2480    Pmsg1(0, _("Begin writing raw blocks of %u bytes.\n"), block->buf_len);
2481    for ( ;; ) {
2482       *p = block_num;
2483       if (dev->is_tape()) {
2484          stat = tape_write(dev->fd, block->buf, block->buf_len);
2485       } else {
2486          stat = write(dev->fd, block->buf, block->buf_len);
2487       }
2488       if (stat == (int)block->buf_len) {
2489          if ((block_num++ % 100) == 0) {
2490             printf("+");
2491             fflush(stdout);
2492          }
2493          p[0] += p[13];
2494          for (i=1; i<(block->buf_len-sizeof(uint32_t))/sizeof(uint32_t)-1; i++) {
2495             p[i] += p[i-1];
2496          }
2497          continue;
2498       }
2499       break;
2500    }
2501    my_errno = errno;
2502    printf("\n");
2503    berrno be;
2504    printf(_("Write failed at block %u. stat=%d ERR=%s\n"), block_num, stat,
2505       be.strerror(my_errno));
2506    weofcmd();
2507 }
2508
2509
2510 /*
2511  * Fill a tape using Bacula block writes
2512  */
2513 static void bfill_cmd()
2514 {
2515    DEV_BLOCK *block = dcr->block;
2516    uint32_t block_num = 0;
2517    uint32_t *p;
2518    int my_errno;
2519    int fd;
2520    uint32_t i;
2521
2522    fd = open("/dev/urandom", O_RDONLY);
2523    if (fd) {
2524       read(fd, block->buf, block->buf_len);
2525       close(fd);
2526    } else {
2527       uint32_t *p = (uint32_t *)block->buf;
2528       srandom(time(NULL));
2529       for (i=0; i<block->buf_len/sizeof(uint32_t); i++) {
2530          p[i] = random();
2531       }
2532    }
2533    p = (uint32_t *)block->buf;
2534    Pmsg1(0, _("Begin writing Bacula blocks of %u bytes.\n"), block->buf_len);
2535    for ( ;; ) {
2536       *p = block_num;
2537       block->binbuf = block->buf_len;
2538       block->bufp = block->buf + block->binbuf;
2539       if (!write_block_to_dev(dcr)) {
2540          break;
2541       }
2542       if ((block_num++ % 100) == 0) {
2543          printf("+");
2544          fflush(stdout);
2545       }
2546       p[0] += p[13];
2547       for (i=1; i<(block->buf_len/sizeof(uint32_t)-1); i++) {
2548          p[i] += p[i-1];
2549       }
2550    }
2551    my_errno = errno;
2552    printf("\n");
2553    printf(_("Write failed at block %u.\n"), block_num);
2554    weofcmd();
2555 }
2556
2557
2558 struct cmdstruct { const char *key; void (*func)(); const char *help; };
2559 static struct cmdstruct commands[] = {
2560  {NT_("autochanger"),autochangercmd, _("test autochanger")},
2561  {NT_("bsf"),       bsfcmd,       _("backspace file")},
2562  {NT_("bsr"),       bsrcmd,       _("backspace record")},
2563  {NT_("bfill"),     bfill_cmd,    _("fill tape using Bacula writes")},
2564  {NT_("cap"),       capcmd,       _("list device capabilities")},
2565  {NT_("clear"),     clearcmd,     _("clear tape errors")},
2566  {NT_("eod"),       eodcmd,       _("go to end of Bacula data for append")},
2567  {NT_("eom"),       eomcmd,       _("go to the physical end of medium")},
2568  {NT_("fill"),      fillcmd,      _("fill tape, write onto second volume")},
2569  {NT_("unfill"),    unfillcmd,    _("read filled tape")},
2570  {NT_("fsf"),       fsfcmd,       _("forward space a file")},
2571  {NT_("fsr"),       fsrcmd,       _("forward space a record")},
2572  {NT_("help"),      helpcmd,      _("print this command")},
2573  {NT_("label"),     labelcmd,     _("write a Bacula label to the tape")},
2574  {NT_("load"),      loadcmd,      _("load a tape")},
2575  {NT_("quit"),      quitcmd,      _("quit btape")},
2576  {NT_("rawfill"),   rawfill_cmd,  _("use write() to fill tape")},
2577  {NT_("readlabel"), readlabelcmd, _("read and print the Bacula tape label")},
2578  {NT_("rectest"),   rectestcmd,   _("test record handling functions")},
2579  {NT_("rewind"),    rewindcmd,    _("rewind the tape")},
2580  {NT_("scan"),      scancmd,      _("read() tape block by block to EOT and report")},
2581  {NT_("scanblocks"),scan_blocks,  _("Bacula read block by block to EOT and report")},
2582  {NT_("status"),    statcmd,      _("print tape status")},
2583  {NT_("test"),      testcmd,      _("General test Bacula tape functions")},
2584  {NT_("weof"),      weofcmd,      _("write an EOF on the tape")},
2585  {NT_("wr"),        wrcmd,        _("write a single Bacula block")},
2586  {NT_("rr"),        rrcmd,        _("read a single record")},
2587  {NT_("rb"),        rbcmd,        _("read a single Bacula block")},
2588  {NT_("qfill"),     qfillcmd,     _("quick fill command")}
2589              };
2590 #define comsize (sizeof(commands)/sizeof(struct cmdstruct))
2591
2592 static void
2593 do_tape_cmds()
2594 {
2595    unsigned int i;
2596    bool found;
2597
2598    while (!quit && get_cmd("*")) {
2599       sm_check(__FILE__, __LINE__, false);
2600       found = false;
2601       parse_args(cmd, &args, &argc, argk, argv, MAX_CMD_ARGS);
2602       for (i=0; i<comsize; i++)       /* search for command */
2603          if (argc > 0 && fstrsch(argk[0],  commands[i].key)) {
2604             (*commands[i].func)();    /* go execute command */
2605             found = true;
2606             break;
2607          }
2608       if (!found) {
2609          Pmsg1(0, _("\"%s\" is an illegal command\n"), cmd);
2610       }
2611    }
2612 }
2613
2614 static void helpcmd()
2615 {
2616    unsigned int i;
2617    usage();
2618    printf(_("Interactive commands:\n"));
2619    printf(_("  Command    Description\n  =======    ===========\n"));
2620    for (i=0; i<comsize; i++)
2621       printf("  %-10s %s\n", commands[i].key, commands[i].help);
2622    printf("\n");
2623 }
2624
2625 static void usage()
2626 {
2627    fprintf(stderr, _(
2628 "Copyright (C) 2000-%s Kern Sibbald.\n"
2629 "\nVersion: %s (%s)\n\n"
2630 "Usage: btape <options> <device_name>\n"
2631 "       -b <file>   specify bootstrap file\n"
2632 "       -c <file>   set configuration file to file\n"
2633 "       -d <nn>     set debug level to nn\n"
2634 "       -p          proceed inspite of I/O errors\n"
2635 "       -s          turn off signals\n"
2636 "       -v          be verbose\n"
2637 "       -?          print this message.\n"
2638 "\n"), BYEAR, VERSION, BDATE);
2639
2640 }
2641
2642 /*
2643  * Get next input command from terminal.  This
2644  * routine is REALLY primitive, and should be enhanced
2645  * to have correct backspacing, etc.
2646  */
2647 int
2648 get_cmd(const char *prompt)
2649 {
2650    int i = 0;
2651    int ch;
2652    fprintf(stdout, prompt);
2653
2654    /* We really should turn off echoing and pretty this
2655     * up a bit.
2656     */
2657    cmd[i] = 0;
2658    while ((ch = fgetc(stdin)) != EOF) {
2659       if (ch == '\n') {
2660          strip_trailing_junk(cmd);
2661          return 1;
2662       } else if (ch == 4 || ch == 0xd3 || ch == 0x8) {
2663          if (i > 0)
2664             cmd[--i] = 0;
2665          continue;
2666       }
2667
2668       cmd[i++] = ch;
2669       cmd[i] = 0;
2670    }
2671    quit = 1;
2672    return 0;
2673 }
2674
2675 /* Dummies to replace askdir.c */
2676 bool    dir_update_file_attributes(DCR *dcr, DEV_RECORD *rec) { return 1;}
2677 bool    dir_send_job_status(JCR *jcr) {return 1;}
2678
2679 bool dir_update_volume_info(DCR *dcr, bool relabel)
2680 {
2681    return 1;
2682 }
2683
2684
2685 bool dir_get_volume_info(DCR *dcr, enum get_vol_info_rw  writing)
2686 {
2687    Dmsg0(20, "Enter dir_get_volume_info\n");
2688    bstrncpy(dcr->VolCatInfo.VolCatName, dcr->VolumeName, sizeof(dcr->VolCatInfo.VolCatName));
2689    return 1;
2690 }
2691
2692 bool dir_create_jobmedia_record(DCR *dcr)
2693 {
2694    dcr->WroteVol = false;
2695    return 1;
2696 }
2697
2698
2699 bool dir_find_next_appendable_volume(DCR *dcr)
2700 {
2701    Dmsg1(20, "Enter dir_find_next_appendable_volume. stop=%d\n", stop);
2702    return dcr->VolumeName[0] != 0;
2703 }
2704
2705 bool dir_ask_sysop_to_mount_volume(DCR *dcr)
2706 {
2707    DEVICE *dev = dcr->dev;
2708    Dmsg0(20, "Enter dir_ask_sysop_to_mount_volume\n");
2709    if (dcr->VolumeName[0] == 0) {
2710       return dir_ask_sysop_to_create_appendable_volume(dcr);
2711    }
2712    Pmsg1(-1, "%s", dev->errmsg);           /* print reason */
2713    if (dcr->VolumeName[0] == 0 || strcmp(dcr->VolumeName, "TestVolume2") == 0) {
2714       fprintf(stderr, _("Mount second Volume on device %s and press return when ready: "),
2715          dev->print_name());
2716    } else {
2717       fprintf(stderr, _("Mount Volume \"%s\" on device %s and press return when ready: "),
2718          dcr->VolumeName, dev->print_name());
2719    }
2720    dev->close();
2721    getchar();
2722    return true;
2723 }
2724
2725 bool dir_ask_sysop_to_create_appendable_volume(DCR *dcr)
2726 {
2727    bool autochanger;
2728    DEVICE *dev = dcr->dev;
2729    Dmsg0(20, "Enter dir_ask_sysop_to_create_appendable_volume\n");
2730    if (stop == 0) {
2731       set_volume_name("TestVolume1", 1);
2732    } else {
2733       set_volume_name("TestVolume2", 2);
2734    }
2735    /* Close device so user can use autochanger if desired */
2736    if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2737       dev->offline();
2738    }
2739    autochanger = autoload_device(dcr, 1, NULL);
2740    if (!autochanger) {
2741       fprintf(stderr, _("Mount blank Volume on device %s and press return when ready: "),
2742          dev->print_name());
2743       dev->close();
2744       getchar();
2745    }
2746    labelcmd();
2747    VolumeName = NULL;
2748    BlockNumber = 0;
2749    return true;
2750 }
2751
2752 static bool my_mount_next_read_volume(DCR *dcr)
2753 {
2754    char ec1[50];
2755    JCR *jcr = dcr->jcr;
2756    DEV_BLOCK *block = dcr->block;
2757
2758    Dmsg0(20, "Enter my_mount_next_read_volume\n");
2759    Pmsg2(000, _("End of Volume \"%s\" %d records.\n"), dcr->VolumeName,
2760       quickie_count);
2761
2762    if (LastBlock != block->BlockNumber) {
2763       VolBytes += block->block_len;
2764    }
2765    LastBlock = block->BlockNumber;
2766    now = time(NULL);
2767    now -= jcr->run_time;
2768    if (now <= 0) {
2769       now = 1;
2770    }
2771    kbs = (double)VolBytes / (1000.0 * (double)now);
2772    Pmsg3(-1, _("Read block=%u, VolBytes=%s rate=%.1f KB/s\n"), block->BlockNumber,
2773             edit_uint64_with_commas(VolBytes, ec1), (float)kbs);
2774
2775    if (strcmp(dcr->VolumeName, "TestVolume2") == 0) {
2776       end_of_tape = 1;
2777       return false;
2778    }
2779
2780    set_volume_name("TestVolume2", 2);
2781
2782    dev->close();
2783    if (!acquire_device_for_read(dcr)) {
2784       Pmsg2(0, _("Cannot open Dev=%s, Vol=%s\n"), dev->print_name(), dcr->VolumeName);
2785       return false;
2786    }
2787    return true;                    /* next volume mounted */
2788 }
2789
2790 static void set_volume_name(const char *VolName, int volnum)
2791 {
2792    DCR *dcr = jcr->dcr;
2793    VolumeName = VolName;
2794    vol_num = volnum;
2795    bstrncpy(dev->VolCatInfo.VolCatName, VolName, sizeof(dev->VolCatInfo.VolCatName));
2796    bstrncpy(dcr->VolCatInfo.VolCatName, VolName, sizeof(dcr->VolCatInfo.VolCatName));
2797    bstrncpy(dcr->VolumeName, VolName, sizeof(dcr->VolumeName));
2798    dcr->VolCatInfo.Slot = volnum;
2799    dcr->VolCatInfo.InChanger = true;
2800 }