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

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