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

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