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