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