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    if (!dev->is_open()) {
1537       open_the_device();
1538    }
1539    sm_check(__FILE__, __LINE__, false);
1540    empty_block(block);
1541    if (verbose > 1) {
1542       dump_block(block, "test");
1543    }
1544
1545    i = block->buf_len - 100;
1546    ASSERT (i > 0);
1547    rec->data = check_pool_memory_size(rec->data, i);
1548    memset(rec->data, i & 0xFF, i);
1549    rec->data_len = i;
1550    sm_check(__FILE__, __LINE__, false);
1551    if (!write_record_to_block(block, rec)) {
1552       Pmsg0(0, _("Error writing record to block.\n"));
1553       goto bail_out;
1554    }
1555    if (!write_block_to_dev(dcr)) {
1556       Pmsg0(0, _("Error writing block to device.\n"));
1557       goto bail_out;
1558    } else {
1559       Pmsg1(0, _("Wrote one record of %d bytes.\n"), i);
1560    }
1561    Pmsg0(0, _("Wrote block to device.\n"));
1562
1563 bail_out:
1564    sm_check(__FILE__, __LINE__, false);
1565    sm_check(__FILE__, __LINE__, false);
1566 }
1567
1568 /*
1569  * Read a record from the tape
1570  */
1571 static void rrcmd()
1572 {
1573    char *buf;
1574    int stat, len;
1575
1576    if (!get_cmd(_("Enter length to read: "))) {
1577       return;
1578    }
1579    len = atoi(cmd);
1580    if (len < 0 || len > 1000000) {
1581       Pmsg0(0, _("Bad length entered, using default of 1024 bytes.\n"));
1582       len = 1024;
1583    }
1584    buf = (char *)malloc(len);
1585    stat = read(dev->fd, buf, len);
1586    if (stat > 0 && stat <= len) {
1587       errno = 0;
1588    }
1589    berrno be;
1590    Pmsg3(0, _("Read of %d bytes gives stat=%d. ERR=%s\n"),
1591       len, stat, be.strerror());
1592    free(buf);
1593 }
1594
1595
1596 /*
1597  * Scan tape by reading block by block. Report what is
1598  * on the tape.  Note, this command does raw reads, and as such
1599  * will not work with fixed block size devices.
1600  */
1601 static void scancmd()
1602 {
1603    int stat;
1604    int blocks, tot_blocks, tot_files;
1605    int block_size;
1606    uint64_t bytes;
1607    char ec1[50];
1608
1609
1610    blocks = block_size = tot_blocks = 0;
1611    bytes = 0;
1612    if (dev->state & ST_EOT) {
1613       Pmsg0(0, _("End of tape\n"));
1614       return;
1615    }
1616    dev->update_pos(dcr);
1617    tot_files = dev->file;
1618    Pmsg1(0, _("Starting scan at file %u\n"), dev->file);
1619    for (;;) {
1620       if ((stat = read(dev->fd, buf, sizeof(buf))) < 0) {
1621          berrno be;
1622          dev->clrerror(-1);
1623          Mmsg2(dev->errmsg, _("read error on %s. ERR=%s.\n"),
1624             dev->dev_name, be.strerror());
1625          Pmsg2(0, _("Bad status from read %d. ERR=%s\n"), stat, dev->bstrerror());
1626          if (blocks > 0) {
1627             if (blocks==1) {
1628                printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1629             }
1630             else {
1631                printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1632             }
1633          }
1634          return;
1635       }
1636       Dmsg1(200, "read status = %d\n", stat);
1637 /*    sleep(1); */
1638       if (stat != block_size) {
1639          dev->update_pos(dcr);
1640          if (blocks > 0) {
1641             if (blocks==1) {
1642                printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1643             }
1644             else {
1645                printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1646             }
1647             blocks = 0;
1648          }
1649          block_size = stat;
1650       }
1651       if (stat == 0) {                /* EOF */
1652          dev->update_pos(dcr);
1653          printf(_("End of File mark.\n"));
1654          /* Two reads of zero means end of tape */
1655          if (dev->state & ST_EOF)
1656             dev->state |= ST_EOT;
1657          else {
1658             dev->state |= ST_EOF;
1659             dev->file++;
1660          }
1661          if (dev->state & ST_EOT) {
1662             printf(_("End of tape\n"));
1663             break;
1664          }
1665       } else {                        /* Got data */
1666          dev->state &= ~ST_EOF;
1667          blocks++;
1668          tot_blocks++;
1669          bytes += stat;
1670       }
1671    }
1672    dev->update_pos(dcr);
1673    tot_files = dev->file - tot_files;
1674    printf(_("Total files=%d, blocks=%d, bytes = %s\n"), tot_files, tot_blocks,
1675       edit_uint64_with_commas(bytes, ec1));
1676 }
1677
1678
1679 /*
1680  * Scan tape by reading Bacula block by block. Report what is
1681  * on the tape.  This function reads Bacula blocks, so if your
1682  * Device resource is correctly defined, it should work with
1683  * either variable or fixed block sizes.
1684  */
1685 static void scan_blocks()
1686 {
1687    int blocks, tot_blocks, tot_files;
1688    uint32_t block_size;
1689    uint64_t bytes;
1690    DEV_BLOCK *block = dcr->block;
1691    char ec1[50];
1692    char buf1[100], buf2[100];
1693
1694    blocks = block_size = tot_blocks = 0;
1695    bytes = 0;
1696
1697    empty_block(block);
1698    dev->update_pos(dcr);
1699    tot_files = dev->file;
1700    for (;;) {
1701       if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
1702          Dmsg1(100, "!read_block(): ERR=%s\n", dev->bstrerror());
1703          if (dev->state & ST_EOT) {
1704             if (blocks > 0) {
1705                if (blocks==1) {
1706                   printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1707                }
1708                else {
1709                   printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1710                }
1711                blocks = 0;
1712             }
1713             goto bail_out;
1714          }
1715          if (dev->state & ST_EOF) {
1716             if (blocks > 0) {
1717                if (blocks==1) {
1718                   printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1719                }
1720                else {
1721                   printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1722                }
1723                blocks = 0;
1724             }
1725             printf(_("End of File mark.\n"));
1726             continue;
1727          }
1728          if (dev->state & ST_SHORT) {
1729             if (blocks > 0) {
1730                if (blocks==1) {
1731                   printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1732                }
1733                else {
1734                   printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1735                }
1736                blocks = 0;
1737             }
1738             printf(_("Short block read.\n"));
1739             continue;
1740          }
1741          printf(_("Error reading block. ERR=%s\n"), dev->bstrerror());
1742          goto bail_out;
1743       }
1744       if (block->block_len != block_size) {
1745          if (blocks > 0) {
1746             if (blocks==1) {
1747                printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1748             }
1749             else {
1750                printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1751             }
1752             blocks = 0;
1753          }
1754          block_size = block->block_len;
1755       }
1756       blocks++;
1757       tot_blocks++;
1758       bytes += block->block_len;
1759       Dmsg6(100, "Blk_blk=%u dev_blk=%u blen=%u bVer=%d SessId=%u SessTim=%u\n",
1760          block->BlockNumber, dev->block_num, block->block_len, block->BlockVer,
1761          block->VolSessionId, block->VolSessionTime);
1762       if (verbose == 1) {
1763          DEV_RECORD *rec = new_record();
1764          read_record_from_block(block, rec);
1765          Pmsg8(-1, _("Blk_block: %u dev_blk=%u blen=%u First rec FI=%s SessId=%u SessTim=%u Strm=%s rlen=%d\n"),
1766               block->BlockNumber, dev->block_num, block->block_len,
1767               FI_to_ascii(buf1, rec->FileIndex), rec->VolSessionId, rec->VolSessionTime,
1768               stream_to_ascii(buf2, rec->Stream, rec->FileIndex), rec->data_len);
1769          rec->remainder = 0;
1770          free_record(rec);
1771       } else if (verbose > 1) {
1772          dump_block(block, "");
1773       }
1774
1775    }
1776 bail_out:
1777    tot_files = dev->file - tot_files;
1778    printf(_("Total files=%d, blocks=%d, bytes = %s\n"), tot_files, tot_blocks,
1779       edit_uint64_with_commas(bytes, ec1));
1780 }
1781
1782
1783 static void statcmd()
1784 {
1785    int debug = debug_level;
1786    debug_level = 30;
1787    Pmsg2(0, _("Device status: %u. ERR=%s\n"), status_dev(dev), dev->bstrerror());
1788 #ifdef xxxx
1789    dump_volume_label(dev);
1790 #endif
1791    debug_level = debug;
1792 }
1793
1794
1795 /*
1796  * First we label the tape, then we fill
1797  *  it with data get a new tape and write a few blocks.
1798  */
1799 static void fillcmd()
1800 {
1801    DEV_RECORD rec;
1802    DEV_BLOCK  *block = dcr->block;
1803    char ec1[50];
1804    char buf1[100], buf2[100];
1805    int fd;
1806    uint32_t i;
1807    uint32_t min_block_size;
1808    struct tm tm;
1809
1810    ok = true;
1811    stop = 0;
1812    vol_num = 0;
1813    last_file = 0;
1814    last_block_num = 0;
1815    BlockNumber = 0;
1816
1817    Pmsg0(-1, _("\n"
1818 "This command simulates Bacula writing to a tape.\n"
1819 "It requires either one or two blank tapes, which it\n"
1820 "will label and write.\n\n"
1821 "If you have an autochanger configured, it will use\n"
1822 "the tapes that are in slots 1 and 2, otherwise, you will\n"
1823 "be prompted to insert the tapes when necessary.\n\n"
1824 "It will print a status approximately\n"
1825 "every 322 MB, and write an EOF every 3.2 GB.  If you have\n"
1826 "selected the simple test option, after writing the first tape\n"
1827 "it will rewind it and re-read the last block written.\n\n"
1828 "If you have selected the multiple tape test, when the first tape\n"
1829 "fills, it will ask for a second, and after writing a few more \n"
1830 "blocks, it will stop.  Then it will begin re-reading the\n"
1831 "two tapes.\n\n"
1832 "This may take a long time -- hours! ...\n\n"));
1833
1834    get_cmd(_("Do you want to run the simplified test (s) with one tape\n"
1835            "or the complete multiple tape (m) test: (s/m) "));
1836    if (cmd[0] == 's') {
1837       Pmsg0(-1, _("Simple test (single tape) selected.\n"));
1838       simple = true;
1839    } else if (cmd[0] == 'm') {
1840       Pmsg0(-1, _("Multiple tape test selected.\n"));
1841       simple = false;
1842    } else {
1843       Pmsg0(000, _("Command aborted.\n"));
1844       return;
1845    }
1846
1847    Dmsg1(20, "Begin append device=%s\n", dev->print_name());
1848    Dmsg1(20, "MaxVolSize=%s\n", edit_uint64(dev->max_volume_size, ec1));
1849
1850    /* Use fixed block size to simplify read back */
1851    min_block_size = dev->min_block_size;
1852    dev->min_block_size = dev->max_block_size;
1853    set_volume_name("TestVolume1", 1);
1854    dir_ask_sysop_to_create_appendable_volume(dcr);
1855    dev->set_append();                 /* force volume to be relabeled */
1856
1857    /*
1858     * Acquire output device for writing.  Note, after acquiring a
1859     *   device, we MUST release it, which is done at the end of this
1860     *   subroutine.
1861     */
1862    Dmsg0(100, "just before acquire_device\n");
1863    if (!acquire_device_for_append(dcr)) {
1864       set_jcr_job_status(jcr, JS_ErrorTerminated);
1865       return;
1866    }
1867    block = jcr->dcr->block;
1868
1869    Dmsg0(100, "Just after acquire_device_for_append\n");
1870    /*
1871     * Write Begin Session Record
1872     */
1873    if (!write_session_label(dcr, SOS_LABEL)) {
1874       set_jcr_job_status(jcr, JS_ErrorTerminated);
1875       Jmsg1(jcr, M_FATAL, 0, _("Write session label failed. ERR=%s\n"),
1876          dev->bstrerror());
1877       ok = false;
1878    }
1879    Pmsg0(-1, _("Wrote Start of Session label.\n"));
1880
1881    memset(&rec, 0, sizeof(rec));
1882    rec.data = get_memory(100000);     /* max record size */
1883
1884 #define REC_SIZE 32768
1885    rec.data_len = REC_SIZE;
1886
1887    /*
1888     * Put some random data in the record
1889     */
1890    fd = open("/dev/urandom", O_RDONLY);
1891    if (fd != -1) {
1892       read(fd, rec.data, rec.data_len);
1893       close(fd);
1894    } else {
1895       uint32_t *p = (uint32_t *)rec.data;
1896       srandom(time(NULL));
1897       for (i=0; i<rec.data_len/sizeof(uint32_t); i++) {
1898          p[i] = random();
1899       }
1900    }
1901
1902    /*
1903     * Generate data as if from File daemon, write to device
1904     */
1905    jcr->dcr->VolFirstIndex = 0;
1906    time(&jcr->run_time);              /* start counting time for rates */
1907    (void)localtime_r(&jcr->run_time, &tm);
1908    strftime(buf1, sizeof(buf1), "%H:%M:%S", &tm);
1909    if (simple) {
1910       Pmsg1(-1, _("%s Begin writing Bacula records to tape ...\n"), buf1);
1911    } else {
1912       Pmsg1(-1, _("%s Begin writing Bacula records to first tape ...\n"), buf1);
1913    }
1914    for (file_index = 0; ok && !job_canceled(jcr); ) {
1915       rec.VolSessionId = jcr->VolSessionId;
1916       rec.VolSessionTime = jcr->VolSessionTime;
1917       rec.FileIndex = ++file_index;
1918       rec.Stream = STREAM_FILE_DATA;
1919
1920       /* Mix up the data just a bit */
1921       uint32_t *lp = (uint32_t *)rec.data;
1922       lp[0] += lp[13];
1923       for (i=1; i < (rec.data_len-sizeof(uint32_t))/sizeof(uint32_t)-1; i++) {
1924          lp[i] += lp[i-1];
1925       }
1926
1927       Dmsg4(250, "before write_rec FI=%d SessId=%d Strm=%s len=%d\n",
1928          rec.FileIndex, rec.VolSessionId,
1929          stream_to_ascii(buf1, rec.Stream, rec.FileIndex),
1930          rec.data_len);
1931
1932       while (!write_record_to_block(block, &rec)) {
1933          /*
1934           * When we get here we have just filled a block
1935           */
1936          Dmsg2(150, "!write_record_to_block data_len=%d rem=%d\n", rec.data_len,
1937                     rec.remainder);
1938
1939          /* Write block to tape */
1940          if (!flush_block(block, 1)) {
1941             break;
1942          }
1943
1944          /* Every 5000 blocks (approx 322MB) report where we are.
1945           */
1946          if ((block->BlockNumber % 5000) == 0) {
1947             now = time(NULL);
1948             now -= jcr->run_time;
1949             if (now <= 0) {
1950                now = 1;          /* prevent divide error */
1951             }
1952             kbs = (double)dev->VolCatInfo.VolCatBytes / (1000.0 * (double)now);
1953             Pmsg4(-1, _("Wrote blk_block=%u, dev_blk_num=%u VolBytes=%s rate=%.1f KB/s\n"),
1954                block->BlockNumber, dev->block_num,
1955                edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, ec1), (float)kbs);
1956          }
1957          /* Every 32000 blocks (approx 2GB) write an EOF.
1958           */
1959          if ((block->BlockNumber % 32000) == 0) {
1960             now = time(NULL);
1961             (void)localtime_r(&now, &tm);
1962             strftime(buf1, sizeof(buf1), "%H:%M:%S", &tm);
1963             Pmsg1(-1, _("%s Flush block, write EOF\n"), buf1);
1964             flush_block(block, 0);
1965             dev->weof(1);
1966          }
1967
1968          /* Get out after writing 10 blocks to the second tape */
1969          if (++BlockNumber > 10 && stop != 0) {      /* get out */
1970             break;
1971          }
1972       }
1973       if (!ok) {
1974          Pmsg0(000, _("Not OK\n"));
1975          break;
1976       }
1977       jcr->JobBytes += rec.data_len;   /* increment bytes this job */
1978       Dmsg4(190, "write_record FI=%s SessId=%d Strm=%s len=%d\n",
1979          FI_to_ascii(buf1, rec.FileIndex), rec.VolSessionId,
1980          stream_to_ascii(buf2, rec.Stream, rec.FileIndex), rec.data_len);
1981
1982       /* Get out after writing 10 blocks to the second tape */
1983       if (BlockNumber > 10 && stop != 0) {      /* get out */
1984          char ed1[50];
1985          Pmsg1(-1, "Done writing %s records ...\n",
1986              edit_uint64_with_commas(write_count, ed1));
1987          break;
1988       }
1989    }
1990    if (vol_num > 1) {
1991       Dmsg0(100, "Write_end_session_label()\n");
1992       /* Create Job status for end of session label */
1993       if (!job_canceled(jcr) && ok) {
1994          set_jcr_job_status(jcr, JS_Terminated);
1995       } else if (!ok) {
1996          set_jcr_job_status(jcr, JS_ErrorTerminated);
1997       }
1998       if (!write_session_label(dcr, EOS_LABEL)) {
1999          Pmsg1(000, _("Error writting end session label. ERR=%s\n"), dev->bstrerror());
2000          ok = false;
2001       }
2002       /* Write out final block of this session */
2003       if (!write_block_to_device(dcr)) {
2004          Pmsg0(-1, _("Set ok=false after write_block_to_device.\n"));
2005          ok = false;
2006       }
2007       Pmsg0(-1, _("Wrote End of Session label.\n"));
2008
2009       /* Save last block info for second tape */
2010       last_block_num2 = last_block_num;
2011       last_file2 = last_file;
2012       if (last_block2) {
2013          free_block(last_block2);
2014       }
2015       last_block2 = dup_block(last_block);
2016    }
2017
2018    sprintf(buf, "%s/btape.state", working_directory);
2019    fd = open(buf, O_CREAT|O_TRUNC|O_WRONLY, 0640);
2020    if (fd >= 0) {
2021       write(fd, &btape_state_level, sizeof(btape_state_level));
2022       write(fd, &simple, sizeof(simple));
2023       write(fd, &last_block_num1, sizeof(last_block_num1));
2024       write(fd, &last_block_num2, sizeof(last_block_num2));
2025       write(fd, &last_file1, sizeof(last_file1));
2026       write(fd, &last_file2, sizeof(last_file2));
2027       write(fd, last_block1->buf, last_block1->buf_len);
2028       write(fd, last_block2->buf, last_block2->buf_len);
2029       write(fd, first_block->buf, first_block->buf_len);
2030       close(fd);
2031       Pmsg2(-1, _("Wrote state file last_block_num1=%d last_block_num2=%d\n"),
2032          last_block_num1, last_block_num2);
2033    } else {
2034       berrno be;
2035       Pmsg2(-1, _("Could not create state file: %s ERR=%s\n"), buf,
2036                  be.strerror());
2037    }
2038
2039    now = time(NULL);
2040    (void)localtime_r(&now, &tm);
2041    strftime(buf1, sizeof(buf1), "%H:%M:%S", &tm);
2042    if (simple) {
2043       Pmsg3(-1, _("\n\n%s Done filling tape at %d:%d. Now beginning re-read of tape ...\n"),
2044          buf1, jcr->dcr->dev->file, jcr->dcr->dev->block_num);
2045    }
2046    else {
2047       Pmsg3(-1, _("\n\n%s Done filling tapes at %d:%d. Now beginning re-read of first tape ...\n"),
2048          buf1, jcr->dcr->dev->file, jcr->dcr->dev->block_num);
2049    }
2050
2051    jcr->dcr->block = block;
2052    do_unfill();
2053
2054    dev->min_block_size = min_block_size;
2055    free_memory(rec.data);
2056 }
2057
2058 /*
2059  * Read two tapes written by the "fill" command and ensure
2060  *  that the data is valid.  If stop==1 we simulate full read back
2061  *  of two tapes.  If stop==-1 we simply read the last block and
2062  *  verify that it is correct.
2063  */
2064 static void unfillcmd()
2065 {
2066    int fd;
2067
2068    last_block1 = new_block(dev);
2069    last_block2 = new_block(dev);
2070    first_block = new_block(dev);
2071    sprintf(buf, "%s/btape.state", working_directory);
2072    fd = open(buf, O_RDONLY);
2073    if (fd >= 0) {
2074       uint32_t state_level;
2075       read(fd, &state_level, sizeof(btape_state_level));
2076       read(fd, &simple, sizeof(simple));
2077       read(fd, &last_block_num1, sizeof(last_block_num1));
2078       read(fd, &last_block_num2, sizeof(last_block_num2));
2079       read(fd, &last_file1, sizeof(last_file1));
2080       read(fd, &last_file2, sizeof(last_file2));
2081       read(fd, last_block1->buf, last_block1->buf_len);
2082       read(fd, last_block2->buf, last_block2->buf_len);
2083       read(fd, first_block->buf, first_block->buf_len);
2084       close(fd);
2085       if (state_level != btape_state_level) {
2086           Pmsg0(-1, _("\nThe state file level has changed. You must redo\n"
2087                   "the fill command.\n"));
2088           return;
2089        }
2090    } else {
2091       berrno be;
2092       Pmsg2(-1, _("\nCould not find the state file: %s ERR=%s\n"
2093              "You must redo the fill command.\n"), buf, be.strerror());
2094       return;
2095    }
2096    do_unfill();
2097    this_block = NULL;
2098 }
2099
2100 static void do_unfill()
2101 {
2102    DEV_BLOCK *block = dcr->block;
2103    bool autochanger;
2104
2105    dumped = 0;
2106    VolBytes = 0;
2107    LastBlock = 0;
2108
2109    Dmsg0(20, "Enter do_unfill\n");
2110    dev->capabilities |= CAP_ANONVOLS; /* allow reading any volume */
2111    dev->capabilities &= ~CAP_LABEL;   /* don't label anything here */
2112
2113    end_of_tape = 0;
2114
2115    time(&jcr->run_time);              /* start counting time for rates */
2116    stop = 0;
2117    file_index = 0;
2118    if (last_block) {
2119       free_block(last_block);
2120       last_block = NULL;
2121    }
2122    last_block_num = last_block_num1;
2123    last_file = last_file1;
2124    last_block = last_block1;
2125
2126    free_restore_volume_list(jcr);
2127    jcr->bsr = NULL;
2128    bstrncpy(dcr->VolumeName, "TestVolume1|TestVolume2", sizeof(dcr->VolumeName));
2129    create_restore_volume_list(jcr);
2130    if (jcr->VolList != NULL) {
2131       jcr->VolList->Slot = 1;
2132       if (jcr->VolList->next != NULL) {
2133          jcr->VolList->next->Slot = 2;
2134       }
2135    }
2136
2137    set_volume_name("TestVolume1", 1);
2138
2139    if (!simple) {
2140       /* Multiple Volume tape */
2141       /* Close device so user can use autochanger if desired */
2142       if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2143          dev->offline();
2144       }
2145       autochanger = autoload_device(dcr, 1, NULL);
2146       if (!autochanger) {
2147          dev->close();
2148          get_cmd(_("Mount first tape. Press enter when ready: "));
2149       }
2150    }
2151
2152    dev->close();
2153    dev->num_writers = 0;
2154    if (!acquire_device_for_read(dcr)) {
2155       Pmsg1(-1, "%s", dev->errmsg);
2156       goto bail_out;
2157    }
2158    /*
2159     * We now have the first tape mounted.
2160     * Note, re-reading last block may have caused us to
2161     *   loose track of where we are (block number unknown).
2162     */
2163    Pmsg0(-1, _("Rewinding.\n"));
2164    if (!dev->rewind(dcr)) {                /* get to a known place on tape */
2165       goto bail_out;
2166    }
2167    /* Read the first 10000 records */
2168    Pmsg2(-1, _("Reading the first 10000 records from %u:%u.\n"),
2169       dev->file, dev->block_num);
2170    quickie_count = 0;
2171    read_records(dcr, quickie_cb, my_mount_next_read_volume);
2172    Pmsg4(-1, _("Reposition from %u:%u to %u:%u\n"), dev->file, dev->block_num,
2173          last_file, last_block_num);
2174    if (!dev->reposition(dcr, last_file, last_block_num)) {
2175       Pmsg1(-1, _("Reposition error. ERR=%s\n"), dev->bstrerror());
2176       goto bail_out;
2177    }
2178    Pmsg1(-1, _("Reading block %u.\n"), last_block_num);
2179    if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2180       Pmsg1(-1, _("Error reading block: ERR=%s\n"), dev->bstrerror());
2181       goto bail_out;
2182    }
2183    if (compare_blocks(last_block, block)) {
2184       if (simple) {
2185          Pmsg0(-1, _("\nThe last block on the tape matches. Test succeeded.\n\n"));
2186       } else {
2187          Pmsg0(-1, _("\nThe last block of the first tape matches.\n\n"));
2188       }
2189    }
2190    if (simple) {
2191       goto bail_out;
2192    }
2193
2194    /* restore info for last block on second Volume */
2195    last_block_num = last_block_num2;
2196    last_file = last_file2;
2197    last_block = last_block2;
2198
2199    /* Multiple Volume tape */
2200    /* Close device so user can use autochanger if desired */
2201    if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2202       dev->offline();
2203    }
2204
2205    set_volume_name("TestVolume2", 2);
2206
2207    autochanger = autoload_device(dcr, 1, NULL);
2208    if (!autochanger) {
2209       dev->close();
2210       get_cmd(_("Mount second tape. Press enter when ready: "));
2211    }
2212
2213    dev->clear_read();
2214    if (!acquire_device_for_read(dcr)) {
2215       Pmsg1(-1, "%s", dev->errmsg);
2216       goto bail_out;
2217    }
2218
2219    /* Space to "first" block which is last block not written
2220     * on the previous tape.
2221     */
2222    Pmsg2(-1, _("Reposition from %u:%u to 0:1\n"), dev->file, dev->block_num);
2223    if (!dev->reposition(dcr, 0, 1)) {
2224       Pmsg1(-1, _("Reposition error. ERR=%s\n"), dev->bstrerror());
2225       goto bail_out;
2226    }
2227    Pmsg1(-1, _("Reading block %d.\n"), dev->block_num);
2228    if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2229       Pmsg1(-1, _("Error reading block: ERR=%s\n"), dev->bstrerror());
2230       goto bail_out;
2231    }
2232    if (compare_blocks(first_block, block)) {
2233       Pmsg0(-1, _("\nThe first block on the second tape matches.\n\n"));
2234    }
2235
2236    /* Now find and compare the last block */
2237    Pmsg4(-1, _("Reposition from %u:%u to %u:%u\n"), dev->file, dev->block_num,
2238          last_file, last_block_num);
2239    if (!dev->reposition(dcr, last_file, last_block_num)) {
2240       Pmsg1(-1, _("Reposition error. ERR=%s\n"), dev->bstrerror());
2241       goto bail_out;
2242    }
2243    Pmsg1(-1, _("Reading block %d.\n"), dev->block_num);
2244    if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2245       Pmsg1(-1, _("Error reading block: ERR=%s\n"), dev->bstrerror());
2246       goto bail_out;
2247    }
2248    if (compare_blocks(last_block, block)) {
2249       Pmsg0(-1, _("\nThe last block on the second tape matches. Test succeeded.\n\n"));
2250    }
2251
2252 bail_out:
2253    free_block(last_block1);
2254    free_block(last_block2);
2255    free_block(first_block);
2256 }
2257
2258 /* Read 10000 records then stop */
2259 static bool quickie_cb(DCR *dcr, DEV_RECORD *rec)
2260 {
2261    DEVICE *dev = dcr->dev;
2262    quickie_count++;
2263    if (quickie_count == 10000) {
2264       Pmsg2(-1, _("10000 records read now at %d:%d\n"), dev->file, dev->block_num);
2265    }
2266    return quickie_count < 10000;
2267 }
2268
2269 static bool compare_blocks(DEV_BLOCK *last_block, DEV_BLOCK *block)
2270 {
2271    char *p, *q;
2272    uint32_t CheckSum, block_len;
2273    ser_declare;
2274
2275    p = last_block->buf;
2276    q = block->buf;
2277    unser_begin(q, BLKHDR2_LENGTH);
2278    unser_uint32(CheckSum);
2279    unser_uint32(block_len);
2280    while (q < (block->buf+block_len)) {
2281       if (*p == *q) {
2282          p++;
2283          q++;
2284          continue;
2285       }
2286       Pmsg0(-1, "\n");
2287       dump_block(last_block, _("Last block written"));
2288       Pmsg0(-1, "\n");
2289       dump_block(block, _("Block read back"));
2290       Pmsg1(-1, _("\n\nThe blocks differ at byte %u\n"), p - last_block->buf);
2291       Pmsg0(-1, _("\n\n!!!! The last block written and the block\n"
2292                 "that was read back differ. The test FAILED !!!!\n"
2293                 "This must be corrected before you use Bacula\n"
2294                 "to write multi-tape Volumes.!!!!\n"));
2295       return false;
2296    }
2297    if (verbose) {
2298       dump_block(last_block, _("Last block written"));
2299       dump_block(block, _("Block read back"));
2300    }
2301    return true;
2302 }
2303
2304
2305
2306
2307
2308 /*
2309  * Write current block to tape regardless of whether or
2310  *   not it is full. If the tape fills, attempt to
2311  *   acquire another tape.
2312  */
2313 static int flush_block(DEV_BLOCK *block, int dump)
2314 {
2315    char ec1[50];
2316    DEV_BLOCK *tblock;
2317    uint32_t this_file, this_block_num;
2318
2319    lock_device(dev);
2320    if (!this_block) {
2321       this_block = new_block(dev);
2322    }
2323    if (!last_block) {
2324       last_block = new_block(dev);
2325    }
2326    /* Copy block */
2327    this_file = dev->file;
2328    this_block_num = dev->block_num;
2329    if (!write_block_to_dev(dcr)) {
2330       Pmsg3(000, _("Last block at: %u:%u this_dev_block_num=%d\n"),
2331                   last_file, last_block_num, this_block_num);
2332       if (vol_num == 1) {
2333          /*
2334           * This is 1st tape, so save first tape info separate
2335           *  from second tape info
2336           */
2337          last_block_num1 = last_block_num;
2338          last_file1 = last_file;
2339          last_block1 = dup_block(last_block);
2340          last_block2 = dup_block(last_block);
2341          first_block = dup_block(block); /* first block second tape */
2342       }
2343       if (verbose) {
2344          Pmsg3(000, _("Block not written: FileIndex=%u blk_block=%u Size=%u\n"),
2345             (unsigned)file_index, block->BlockNumber, block->block_len);
2346          dump_block(last_block, _("Last block written"));
2347          Pmsg0(-1, "\n");
2348          dump_block(block, _("Block not written"));
2349       }
2350       if (stop == 0) {
2351          eot_block = block->BlockNumber;
2352          eot_block_len = block->block_len;
2353          eot_FileIndex = file_index;
2354          stop = 1;
2355       }
2356       now = time(NULL);
2357       now -= jcr->run_time;
2358       if (now <= 0) {
2359          now = 1;                     /* don't divide by zero */
2360       }
2361       kbs = (double)dev->VolCatInfo.VolCatBytes / (1000 * now);
2362       vol_size = dev->VolCatInfo.VolCatBytes;
2363       Pmsg4(000, _("End of tape %d:%d. VolumeCapacity=%s. Write rate = %.1f KB/s\n"),
2364          dev->file, dev->block_num,
2365          edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, ec1), kbs);
2366
2367       if (simple) {
2368          stop = -1;                   /* stop, but do simplified test */
2369       } else {
2370          /* Full test in progress */
2371          if (!fixup_device_block_write_error(jcr->dcr)) {
2372             Pmsg1(000, _("Cannot fixup device error. %s\n"), dev->bstrerror());
2373             ok = false;
2374             unlock_device(dev);
2375             return 0;
2376          }
2377          BlockNumber = 0;             /* start counting for second tape */
2378       }
2379       unlock_device(dev);
2380       return 1;                       /* end of tape reached */
2381    }
2382
2383    /* Save contents after write so that the header is serialized */
2384    memcpy(this_block->buf, block->buf, this_block->buf_len);
2385
2386    /*
2387     * Note, we always read/write to block, but we toggle
2388     *  copying it to one or another of two allocated blocks.
2389     * Switch blocks so that the block just successfully written is
2390     *  always in last_block.
2391     */
2392    tblock = last_block;
2393    last_block = this_block;
2394    this_block = tblock;
2395    last_file = this_file;
2396    last_block_num = this_block_num;
2397
2398    unlock_device(dev);
2399    return 1;
2400 }
2401
2402
2403 /*
2404  * First we label the tape, then we fill
2405  *  it with data get a new tape and write a few blocks.
2406  */
2407 static void qfillcmd()
2408 {
2409    DEV_BLOCK *block = dcr->block;
2410    DEV_RECORD *rec = dcr->rec;
2411    int i, count;
2412
2413    Pmsg0(0, _("Test writing blocks of 64512 bytes to tape.\n"));
2414
2415    get_cmd(_("How many blocks do you want to write? (1000): "));
2416
2417    count = atoi(cmd);
2418    if (count <= 0) {
2419       count = 1000;
2420    }
2421
2422    sm_check(__FILE__, __LINE__, false);
2423
2424    i = block->buf_len - 100;
2425    ASSERT (i > 0);
2426    rec->data = check_pool_memory_size(rec->data, i);
2427    memset(rec->data, i & 0xFF, i);
2428    rec->data_len = i;
2429    rewindcmd();
2430    Pmsg1(0, _("Begin writing %d Bacula blocks to tape ...\n"), count);
2431    for (i=0; i < count; i++) {
2432       if (i % 100 == 0) {
2433          printf("+");
2434          fflush(stdout);
2435       }
2436       if (!write_record_to_block(block, rec)) {
2437          Pmsg0(0, _("Error writing record to block.\n"));
2438          goto bail_out;
2439       }
2440       if (!write_block_to_dev(dcr)) {
2441          Pmsg0(0, _("Error writing block to device.\n"));
2442          goto bail_out;
2443       }
2444    }
2445    printf("\n");
2446    weofcmd();
2447    if (dev_cap(dev, CAP_TWOEOF)) {
2448       weofcmd();
2449    }
2450    rewindcmd();
2451    scan_blocks();
2452
2453 bail_out:
2454    sm_check(__FILE__, __LINE__, false);
2455 }
2456
2457 /*
2458  * Fill a tape using raw write() command
2459  */
2460 static void rawfill_cmd()
2461 {
2462    DEV_BLOCK *block = dcr->block;
2463    int stat;
2464    int fd;
2465    uint32_t block_num = 0;
2466    uint32_t *p;
2467    int my_errno;
2468    uint32_t i;
2469
2470    fd = open("/dev/urandom", O_RDONLY);
2471    if (fd) {
2472       read(fd, block->buf, block->buf_len);
2473       close(fd);
2474    } else {
2475       uint32_t *p = (uint32_t *)block->buf;
2476       srandom(time(NULL));
2477       for (i=0; i<block->buf_len/sizeof(uint32_t); i++) {
2478          p[i] = random();
2479       }
2480    }
2481    p = (uint32_t *)block->buf;
2482    Pmsg1(0, _("Begin writing raw blocks of %u bytes.\n"), block->buf_len);
2483    for ( ;; ) {
2484       *p = block_num;
2485       if (dev->is_tape()) {
2486          stat = tape_write(dev->fd, block->buf, block->buf_len);
2487       } else {
2488          stat = write(dev->fd, block->buf, block->buf_len);
2489       }
2490       if (stat == (int)block->buf_len) {
2491          if ((block_num++ % 100) == 0) {
2492             printf("+");
2493             fflush(stdout);
2494          }
2495          p[0] += p[13];
2496          for (i=1; i<(block->buf_len-sizeof(uint32_t))/sizeof(uint32_t)-1; i++) {
2497             p[i] += p[i-1];
2498          }
2499          continue;
2500       }
2501       break;
2502    }
2503    my_errno = errno;
2504    printf("\n");
2505    berrno be;
2506    printf(_("Write failed at block %u. stat=%d ERR=%s\n"), block_num, stat,
2507       be.strerror(my_errno));
2508    weofcmd();
2509 }
2510
2511
2512 /*
2513  * Fill a tape using Bacula block writes
2514  */
2515 static void bfill_cmd()
2516 {
2517    DEV_BLOCK *block = dcr->block;
2518    uint32_t block_num = 0;
2519    uint32_t *p;
2520    int my_errno;
2521    int fd;
2522    uint32_t i;
2523
2524    fd = open("/dev/urandom", O_RDONLY);
2525    if (fd) {
2526       read(fd, block->buf, block->buf_len);
2527       close(fd);
2528    } else {
2529       uint32_t *p = (uint32_t *)block->buf;
2530       srandom(time(NULL));
2531       for (i=0; i<block->buf_len/sizeof(uint32_t); i++) {
2532          p[i] = random();
2533       }
2534    }
2535    p = (uint32_t *)block->buf;
2536    Pmsg1(0, _("Begin writing Bacula blocks of %u bytes.\n"), block->buf_len);
2537    for ( ;; ) {
2538       *p = block_num;
2539       block->binbuf = block->buf_len;
2540       block->bufp = block->buf + block->binbuf;
2541       if (!write_block_to_dev(dcr)) {
2542          break;
2543       }
2544       if ((block_num++ % 100) == 0) {
2545          printf("+");
2546          fflush(stdout);
2547       }
2548       p[0] += p[13];
2549       for (i=1; i<(block->buf_len/sizeof(uint32_t)-1); i++) {
2550          p[i] += p[i-1];
2551       }
2552    }
2553    my_errno = errno;
2554    printf("\n");
2555    printf(_("Write failed at block %u.\n"), block_num);
2556    weofcmd();
2557 }
2558
2559
2560 struct cmdstruct { const char *key; void (*func)(); const char *help; };
2561 static struct cmdstruct commands[] = {
2562  {NT_("autochanger"),autochangercmd, _("test autochanger")},
2563  {NT_("bsf"),       bsfcmd,       _("backspace file")},
2564  {NT_("bsr"),       bsrcmd,       _("backspace record")},
2565  {NT_("bfill"),     bfill_cmd,    _("fill tape using Bacula writes")},
2566  {NT_("cap"),       capcmd,       _("list device capabilities")},
2567  {NT_("clear"),     clearcmd,     _("clear tape errors")},
2568  {NT_("eod"),       eodcmd,       _("go to end of Bacula data for append")},
2569  {NT_("eom"),       eomcmd,       _("go to the physical end of medium")},
2570  {NT_("fill"),      fillcmd,      _("fill tape, write onto second volume")},
2571  {NT_("unfill"),    unfillcmd,    _("read filled tape")},
2572  {NT_("fsf"),       fsfcmd,       _("forward space a file")},
2573  {NT_("fsr"),       fsrcmd,       _("forward space a record")},
2574  {NT_("help"),      helpcmd,      _("print this command")},
2575  {NT_("label"),     labelcmd,     _("write a Bacula label to the tape")},
2576  {NT_("load"),      loadcmd,      _("load a tape")},
2577  {NT_("quit"),      quitcmd,      _("quit btape")},
2578  {NT_("rawfill"),   rawfill_cmd,  _("use write() to fill tape")},
2579  {NT_("readlabel"), readlabelcmd, _("read and print the Bacula tape label")},
2580  {NT_("rectest"),   rectestcmd,   _("test record handling functions")},
2581  {NT_("rewind"),    rewindcmd,    _("rewind the tape")},
2582  {NT_("scan"),      scancmd,      _("read() tape block by block to EOT and report")},
2583  {NT_("scanblocks"),scan_blocks,  _("Bacula read block by block to EOT and report")},
2584  {NT_("status"),    statcmd,      _("print tape status")},
2585  {NT_("test"),      testcmd,      _("General test Bacula tape functions")},
2586  {NT_("weof"),      weofcmd,      _("write an EOF on the tape")},
2587  {NT_("wr"),        wrcmd,        _("write a single Bacula block")},
2588  {NT_("rr"),        rrcmd,        _("read a single record")},
2589  {NT_("rb"),        rbcmd,        _("read a single Bacula block")},
2590  {NT_("qfill"),     qfillcmd,     _("quick fill command")}
2591              };
2592 #define comsize (sizeof(commands)/sizeof(struct cmdstruct))
2593
2594 static void
2595 do_tape_cmds()
2596 {
2597    unsigned int i;
2598    bool found;
2599
2600    while (!quit && get_cmd("*")) {
2601       sm_check(__FILE__, __LINE__, false);
2602       found = false;
2603       parse_args(cmd, &args, &argc, argk, argv, MAX_CMD_ARGS);
2604       for (i=0; i<comsize; i++)       /* search for command */
2605          if (argc > 0 && fstrsch(argk[0],  commands[i].key)) {
2606             (*commands[i].func)();    /* go execute command */
2607             found = true;
2608             break;
2609          }
2610       if (!found) {
2611          Pmsg1(0, _("\"%s\" is an illegal command\n"), cmd);
2612       }
2613    }
2614 }
2615
2616 static void helpcmd()
2617 {
2618    unsigned int i;
2619    usage();
2620    printf(_("Interactive commands:\n"));
2621    printf(_("  Command    Description\n  =======    ===========\n"));
2622    for (i=0; i<comsize; i++)
2623       printf("  %-10s %s\n", commands[i].key, commands[i].help);
2624    printf("\n");
2625 }
2626
2627 static void usage()
2628 {
2629    fprintf(stderr, _(
2630 "Copyright (C) 2000-%s Kern Sibbald.\n"
2631 "\nVersion: %s (%s)\n\n"
2632 "Usage: btape <options> <device_name>\n"
2633 "       -b <file>   specify bootstrap file\n"
2634 "       -c <file>   set configuration file to file\n"
2635 "       -d <nn>     set debug level to nn\n"
2636 "       -p          proceed inspite of I/O errors\n"
2637 "       -s          turn off signals\n"
2638 "       -v          be verbose\n"
2639 "       -?          print this message.\n"
2640 "\n"), BYEAR, VERSION, BDATE);
2641
2642 }
2643
2644 /*
2645  * Get next input command from terminal.  This
2646  * routine is REALLY primitive, and should be enhanced
2647  * to have correct backspacing, etc.
2648  */
2649 int
2650 get_cmd(const char *prompt)
2651 {
2652    int i = 0;
2653    int ch;
2654    fprintf(stdout, prompt);
2655
2656    /* We really should turn off echoing and pretty this
2657     * up a bit.
2658     */
2659    cmd[i] = 0;
2660    while ((ch = fgetc(stdin)) != EOF) {
2661       if (ch == '\n') {
2662          strip_trailing_junk(cmd);
2663          return 1;
2664       } else if (ch == 4 || ch == 0xd3 || ch == 0x8) {
2665          if (i > 0)
2666             cmd[--i] = 0;
2667          continue;
2668       }
2669
2670       cmd[i++] = ch;
2671       cmd[i] = 0;
2672    }
2673    quit = 1;
2674    return 0;
2675 }
2676
2677 /* Dummies to replace askdir.c */
2678 bool    dir_update_file_attributes(DCR *dcr, DEV_RECORD *rec) { return 1;}
2679 bool    dir_send_job_status(JCR *jcr) {return 1;}
2680
2681 bool dir_update_volume_info(DCR *dcr, bool relabel)
2682 {
2683    return 1;
2684 }
2685
2686
2687 bool dir_get_volume_info(DCR *dcr, enum get_vol_info_rw  writing)
2688 {
2689    Dmsg0(20, "Enter dir_get_volume_info\n");
2690    bstrncpy(dcr->VolCatInfo.VolCatName, dcr->VolumeName, sizeof(dcr->VolCatInfo.VolCatName));
2691    return 1;
2692 }
2693
2694 bool dir_create_jobmedia_record(DCR *dcr)
2695 {
2696    dcr->WroteVol = false;
2697    return 1;
2698 }
2699
2700
2701 bool dir_find_next_appendable_volume(DCR *dcr)
2702 {
2703    Dmsg1(20, "Enter dir_find_next_appendable_volume. stop=%d\n", stop);
2704    return dcr->VolumeName[0] != 0;
2705 }
2706
2707 bool dir_ask_sysop_to_mount_volume(DCR *dcr)
2708 {
2709    DEVICE *dev = dcr->dev;
2710    Dmsg0(20, "Enter dir_ask_sysop_to_mount_volume\n");
2711    if (dcr->VolumeName[0] == 0) {
2712       return dir_ask_sysop_to_create_appendable_volume(dcr);
2713    }
2714    Pmsg1(-1, "%s", dev->errmsg);           /* print reason */
2715    if (dcr->VolumeName[0] == 0 || strcmp(dcr->VolumeName, "TestVolume2") == 0) {
2716       fprintf(stderr, _("Mount second Volume on device %s and press return when ready: "),
2717          dev->print_name());
2718    } else {
2719       fprintf(stderr, _("Mount Volume \"%s\" on device %s and press return when ready: "),
2720          dcr->VolumeName, dev->print_name());
2721    }
2722    dev->close();
2723    getchar();
2724    return true;
2725 }
2726
2727 bool dir_ask_sysop_to_create_appendable_volume(DCR *dcr)
2728 {
2729    bool autochanger;
2730    DEVICE *dev = dcr->dev;
2731    Dmsg0(20, "Enter dir_ask_sysop_to_create_appendable_volume\n");
2732    if (stop == 0) {
2733       set_volume_name("TestVolume1", 1);
2734    } else {
2735       set_volume_name("TestVolume2", 2);
2736    }
2737    /* Close device so user can use autochanger if desired */
2738    if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2739       dev->offline();
2740    }
2741    autochanger = autoload_device(dcr, 1, NULL);
2742    if (!autochanger) {
2743       fprintf(stderr, _("Mount blank Volume on device %s and press return when ready: "),
2744          dev->print_name());
2745       dev->close();
2746       getchar();
2747    }
2748    labelcmd();
2749    VolumeName = NULL;
2750    BlockNumber = 0;
2751    return true;
2752 }
2753
2754 static bool my_mount_next_read_volume(DCR *dcr)
2755 {
2756    char ec1[50];
2757    JCR *jcr = dcr->jcr;
2758    DEV_BLOCK *block = dcr->block;
2759
2760    Dmsg0(20, "Enter my_mount_next_read_volume\n");
2761    Pmsg2(000, _("End of Volume \"%s\" %d records.\n"), dcr->VolumeName,
2762       quickie_count);
2763
2764    if (LastBlock != block->BlockNumber) {
2765       VolBytes += block->block_len;
2766    }
2767    LastBlock = block->BlockNumber;
2768    now = time(NULL);
2769    now -= jcr->run_time;
2770    if (now <= 0) {
2771       now = 1;
2772    }
2773    kbs = (double)VolBytes / (1000.0 * (double)now);
2774    Pmsg3(-1, _("Read block=%u, VolBytes=%s rate=%.1f KB/s\n"), block->BlockNumber,
2775             edit_uint64_with_commas(VolBytes, ec1), (float)kbs);
2776
2777    if (strcmp(dcr->VolumeName, "TestVolume2") == 0) {
2778       end_of_tape = 1;
2779       return false;
2780    }
2781
2782    set_volume_name("TestVolume2", 2);
2783
2784    dev->close();
2785    if (!acquire_device_for_read(dcr)) {
2786       Pmsg2(0, _("Cannot open Dev=%s, Vol=%s\n"), dev->print_name(), dcr->VolumeName);
2787       return false;
2788    }
2789    return true;                    /* next volume mounted */
2790 }
2791
2792 static void set_volume_name(const char *VolName, int volnum)
2793 {
2794    DCR *dcr = jcr->dcr;
2795    VolumeName = VolName;
2796    vol_num = volnum;
2797    bstrncpy(dev->VolCatInfo.VolCatName, VolName, sizeof(dev->VolCatInfo.VolCatName));
2798    bstrncpy(dcr->VolCatInfo.VolCatName, VolName, sizeof(dcr->VolCatInfo.VolCatName));
2799    bstrncpy(dcr->VolumeName, VolName, sizeof(dcr->VolumeName));
2800    dcr->VolCatInfo.Slot = volnum;
2801    dcr->VolCatInfo.InChanger = true;
2802 }