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